@mui/x-data-grid-premium 8.13.0 → 8.14.0

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

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { gridRowTreeSelector, gridColumnLookupSelector } from '@mui/x-data-grid-pro';
-import { useGridRegisterStrategyProcessor, createRowTree, updateRowTree, getVisibleRowsLookup, skipSorting, skipFiltering, getParentPath, RowGroupingStrategy } from '@mui/x-data-grid-pro/internals';
+import { useGridRegisterStrategyProcessor, createRowTree, updateRowTree, getVisibleRowsLookup, skipSorting, skipFiltering, getParentPath, RowGroupingStrategy, gridPivotActiveSelector } from '@mui/x-data-grid-pro/internals';
 import { getGroupingRules } from "./gridRowGroupingUtils.js";
 import { gridRowGroupingSanitizedModelSelector } from "./gridRowGroupingSelector.js";
 export const useGridDataSourceRowGroupingPreProcessors = (apiRef, props) => {
@@ -13,7 +13,9 @@ export const useGridDataSourceRowGroupingPreProcessors = (apiRef, props) => {
     if (!getChildrenCount) {
       throw new Error('MUI X: No `getChildrenCount` method provided with the dataSource.');
     }
+    const pivotingActive = gridPivotActiveSelector(apiRef);
     const sanitizedRowGroupingModel = gridRowGroupingSanitizedModelSelector(apiRef);
+    const maxDepth = pivotingActive ? sanitizedRowGroupingModel.length - 1 : undefined;
     const columnsLookup = gridColumnLookupSelector(apiRef);
     const groupingRules = getGroupingRules({
       sanitizedRowGroupingModel,
@@ -38,7 +40,8 @@ export const useGridDataSourceRowGroupingPreProcessors = (apiRef, props) => {
         nodes: params.updates.rows.map(getRowTreeBuilderNode),
         defaultGroupingExpansionDepth: props.defaultGroupingExpansionDepth,
         isGroupExpandedByDefault: props.isGroupExpandedByDefault,
-        groupingName: RowGroupingStrategy.DataSource
+        groupingName: RowGroupingStrategy.DataSource,
+        maxDepth
       });
     }
     return updateRowTree({
@@ -52,7 +55,8 @@ export const useGridDataSourceRowGroupingPreProcessors = (apiRef, props) => {
       previousTreeDepth: params.previousTreeDepths,
       defaultGroupingExpansionDepth: props.defaultGroupingExpansionDepth,
       isGroupExpandedByDefault: props.isGroupExpandedByDefault,
-      groupingName: RowGroupingStrategy.DataSource
+      groupingName: RowGroupingStrategy.DataSource,
+      maxDepth
     });
   }, [apiRef, props.dataSource, props.defaultGroupingExpansionDepth, props.isGroupExpandedByDefault]);
   const filterRows = React.useCallback(() => {

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

@@ -8,4 +8,4 @@ export declare const rowGroupingStateInitializer: GridStateInitializer<Pick<Data
  * @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" | "rowGroupingColumnMode" | "disableRowGrouping" | "slotProps" | "slots" | "dataSource" | "treeData">) => void;
+export declare const useGridRowGrouping: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "initialState" | "rowGroupingModel" | "onRowGroupingModelChange" | "isGroupExpandedByDefault" | "rowGroupingColumnMode" | "disableRowGrouping" | "slotProps" | "slots" | "dataSource" | "treeData">) => void;

package/esm/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-data-grid-premium v8.13.0
+ * @mui/x-data-grid-premium v8.14.0
  *
  * @license SEE LICENSE IN LICENSE
  * This source code is licensed under the SEE LICENSE IN LICENSE license found in the

package/esm/models/dataGridPremiumProps.d.ts

@@ -8,7 +8,7 @@ import { GridPremiumSlotProps } from "./gridPremiumSlotProps.js";
 import { GridInitialStatePremium } from "./gridStatePremium.js";
 import { GridApiPremium } from "./gridApiPremium.js";
 import { GridCellSelectionModel } from "../hooks/features/cellSelection/index.js";
-import type { GridPivotingColDefOverrides, GridPivotModel } from "../hooks/features/pivoting/gridPivotingInterfaces.js";
+import type { GridPivotingColDefOverrides, PivotingColDefCallback, GridPivotModel } from "../hooks/features/pivoting/gridPivotingInterfaces.js";
 import { GridDataSourcePremium as GridDataSource, GridGetRowsParamsPremium as GridGetRowsParams } from "../hooks/features/dataSource/models.js";
 import { Conversation, PromptResponse, PromptSuggestion } from "../hooks/features/aiAssistant/gridAiAssistantInterfaces.js";
 export interface GridExperimentalPremiumFeatures extends GridExperimentalProFeatures {
@@ -91,15 +91,6 @@ export interface DataGridPremiumPropsWithDefaultValue<R extends GridValidRowMode
    * @default false
    */
   disablePivoting: boolean;
-  /**
-   * Allows to generate derived columns from actual columns that will be used for pivoting.
-   * Useful e.g. for date columns to generate year, quarter, month, etc.
-   * @param {GridColDef} column The column to generate derived columns for.
-   * @param {GridLocaleTextApi['getLocaleText']} getLocaleText The function to get the locale text.
-   * @returns {GridColDef[] | undefined} The derived columns.
-   * @default {defaultGetPivotDerivedColumns} Creates year and quarter columns for date columns.
-   */
-  getPivotDerivedColumns: ((column: GridColDef, getLocaleText: GridLocaleTextApi['getLocaleText']) => GridColDef[] | undefined) | null;
   /**
    * If `true`, the AI Assistant is enabled.
    * @default false
@@ -226,14 +217,24 @@ export interface DataGridPremiumPropsWithoutDefaultValue<R extends GridValidRowM
    * @deprecated Use the `sidebarOpen` and `sidebarClose` events or corresponding event handlers `onSidebarOpen()` and `onSidebarClose()` instead.
    */
   onPivotPanelOpenChange?: (pivotPanelOpen: boolean) => void;
+  /**
+   * Allows to generate derived columns from actual columns that will be used for pivoting.
+   * Useful e.g. for date columns to generate year, quarter, month, etc.
+   * @param {GridColDef} column The column to generate derived columns for.
+   * @param {GridLocaleTextApi['getLocaleText']} getLocaleText The function to get the locale text.
+   * @returns {GridColDef[] | undefined} The derived columns.
+   * @default {defaultGetPivotDerivedColumns | undefined} Creates year and quarter columns for date columns if not in server side mode.
+   */
+  getPivotDerivedColumns?: ((column: GridColDef, getLocaleText: GridLocaleTextApi['getLocaleText']) => GridColDef[] | undefined) | null;
   /**
    * The column definition overrides for the columns generated by the pivoting feature.
-   * @param {string} originalColumnField The field of the original column.
-   * @param {string[]} columnGroupPath The path of the column groups the column belongs to.
-   * @returns {Partial<GridPivotingColDefOverrides> | undefined | void} The column definition overrides.
+   * Pass either a partial column definition to apply the same overrides to all pivot columns, or a callback to apply different overrides to each pivot column.
+   * For server-side pivoting, only the `PivotingColDefCallback` signature is supported, and the prop is required.
+   * @type {Partial<GridPivotingColDefOverrides> | PivotingColDefCallback}
    * @default undefined
+   * @throws {Error} If `undefined` and `dataSource` is provided.
    */
-  pivotingColDef?: Partial<GridPivotingColDefOverrides> | ((originalColumnField: GridColDef['field'], columnGroupPath: string[]) => Partial<GridPivotingColDefOverrides> | undefined);
+  pivotingColDef?: Partial<GridPivotingColDefOverrides> | PivotingColDefCallback;
   /**
    * The conversations with the AI Assistant.
    */

package/hooks/features/aggregation/useGridAggregation.js

@@ -164,6 +164,7 @@ const useGridAggregation = (apiRef, props) => {
    * EVENTS
    */
   const checkAggregationRulesDiff = React.useCallback(() => {
+    const pivotingActive = (0, _internals.gridPivotActiveSelector)(apiRef);
     const {
       rulesOnLastRowHydration,
       rulesOnLastColumnHydration
@@ -171,7 +172,7 @@ const useGridAggregation = (apiRef, props) => {
     const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)((0, _xDataGridPro.gridColumnLookupSelector)(apiRef), (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.dataSource);
 
     // Re-apply the row hydration to add / remove the aggregation footers
-    if (!props.dataSource && !(0, _gridAggregationUtils.areAggregationRulesEqual)(rulesOnLastRowHydration, aggregationRules)) {
+    if ((!props.dataSource || pivotingActive) && !(0, _gridAggregationUtils.areAggregationRulesEqual)(rulesOnLastRowHydration, aggregationRules)) {
       apiRef.current.requestPipeProcessorsApplication('hydrateRows');
       deferredApplyAggregation();
     }

package/hooks/features/dataSource/models.d.ts

@@ -1,5 +1,22 @@
-import type { GridColDef, GridRowId, GridValidRowModel, GridDataSource, GridGetRowsResponse, GridGetRowsParams, GridDataSourceApiBase, GridDataSourcePrivateApi } from '@mui/x-data-grid-pro';
+import type { GridColDef, GridRowId, GridValidRowModel, GridDataSource, GridGetRowsResponse, GridGetRowsParams, GridDataSourceApiBase, GridDataSourcePrivateApi, GridRowModel } from '@mui/x-data-grid-pro';
 import type { GridAggregationModel } from "../aggregation/gridAggregationInterfaces.js";
+import type { GridPivotModel } from "../pivoting/gridPivotingInterfaces.js";
+export interface GridGetRowsResponsePivotColumn {
+  key: string;
+  group: string | GridRowModel;
+  children?: GridGetRowsResponsePivotColumn[];
+}
+/**
+ * Path to a pivot column group.
+ * @param {string} key Pivot column key.
+ * @param {string} field Pivot column field.
+ * @param {string | GridRowModel} value Path value that is either a string or a part of row model needed to get the formatted value of the original column.
+ */
+export interface GridDataSourcePivotColumnGroupPath {
+  key: string;
+  field: string;
+  value: string | GridRowModel;
+}
 export interface GridGetRowsResponsePremium extends GridGetRowsResponse {
   /**
    * Row to be used for aggregation footer row.
@@ -7,6 +24,32 @@ export interface GridGetRowsResponsePremium extends GridGetRowsResponse {
    * `GridGetRowsParams.aggregationModel`.
    */
   aggregateRow?: GridValidRowModel;
+  /**
+   * Defines the structure of pivot columns to be created from the pivoted data.
+   * Each node in the tree must have a `key` and `group` property.
+   * `key` is used to identify the column group and will be passed to the `pivotingColDef` callback as the column path parameter.
+   * `group` is either a string or a part of a row model needed to get the formatted value of the original column.
+   * optionally,`children` is a list of the next level nodes.
+   * Each node at the last level of the tree will be a column group containing each pivot value as a column.
+   *
+   * Structure:
+   * The `group` property can be a string or an object:
+   *   - Strings are used directly as column group header names (e.g. `"2025"`, `"January"`)
+   *   - Objects contain data that will be formatted into header names using the column's valueFormatter or valueGetter
+   *     (e.g. `{date: "2025-01-01"}` could be formatted as `"Jan 2025"`)
+   *
+   * Examples:
+   * - `[{key: "Y", group: "Yes"}, {key: "N", group: "No"}]` - Creates column groups with values "Yes" and "No"
+   * - `[{key: "2025", group: "2025", children: [{key: "January", group: "January"}, {key: "February", group: "February"}]}]` - Creates a column group with value "2025"
+   *   that has column groups "January" and "February"
+   * - `[
+   *      {key: "2025-01", group: {date: "2025-01-01"}, children: [{key: "01", group: {date: "2025-01-01"}}]},
+   *      {key: "2025-02", group: {date: "2025-02-01"}, children: [{key: "02", group: {date: "2025-02-01"}}]},
+   *    ]` - Creates two levels of column groups with values returned from the value formatters of the columns used for pivoting.
+   *   Even though the same values are passed, the header names can be different based on the valueFormatter or valueGetter.
+   *   One pivoting column may format the date as a year and the other as a month.
+   */
+  pivotColumns?: GridGetRowsResponsePivotColumn[];
 }
 export interface GridGetRowsParamsPremium extends GridGetRowsParams {
   /**
@@ -17,6 +60,14 @@ export interface GridGetRowsParamsPremium extends GridGetRowsParams {
    * List of grouped columns (only applicable with `rowGrouping`).
    */
   groupFields?: GridColDef['field'][];
+  /**
+   * Visible rows, columns and values from the pivot model (only applicable with `pivoting`).
+   */
+  pivotModel?: {
+    columns: Omit<GridPivotModel['columns'], 'hidden'>;
+    rows: Omit<GridPivotModel['rows'], 'hidden'>;
+    values: Omit<GridPivotModel['values'], 'hidden'>;
+  };
 }
 export interface GridDataSourcePremium extends Omit<GridDataSource, 'getRows'> {
   /**

package/hooks/features/dataSource/useGridDataSourcePremium.js

@@ -11,8 +11,10 @@ var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")
 var React = _interopRequireWildcard(require("react"));
 var _xDataGridPro = require("@mui/x-data-grid-pro");
 var _internals = require("@mui/x-data-grid-pro/internals");
+var _gridPivotingSelectors = require("../pivoting/gridPivotingSelectors");
+var _utils = require("./utils");
 function getKeyPremium(params) {
-  return JSON.stringify([params.filterModel, params.sortModel, params.groupKeys, params.groupFields, params.start, params.end, params.aggregationModel]);
+  return JSON.stringify([params.filterModel, params.sortModel, params.groupKeys, params.groupFields, params.start, params.end, params.pivotModel ? {} : params.aggregationModel, params.pivotModel]);
 }
 const options = {
   cacheOptions: {
@@ -28,6 +30,9 @@ const useGridDataSourcePremium = (apiRef, props) => {
     setStrategyAvailability
   } = (0, _internals.useGridDataSourceBasePro)(apiRef, props, options);
   const aggregateRowRef = React.useRef({});
+  const initialColumns = (0, _internals.gridPivotInitialColumnsSelector)(apiRef);
+  const pivotActive = (0, _internals.gridPivotActiveSelector)(apiRef);
+  const pivotModel = (0, _gridPivotingSelectors.gridPivotModelSelector)(apiRef);
   const processDataSourceRows = React.useCallback(({
     params,
     response
@@ -41,11 +46,29 @@ const useGridDataSourcePremium = (apiRef, props) => {
       }
       apiRef.current.applyAggregation();
     }
+    if (response.pivotColumns) {
+      const pivotingColDef = props.pivotingColDef;
+      if (!pivotingColDef || typeof pivotingColDef !== 'function') {
+        throw new Error('MUI X: No `pivotingColDef()` prop provided with to the Data Grid, but response contains `pivotColumns`.\n\n\
+            You need a callback to return at least a field column prop for each generated pivot column.\n\n\
+            See [server-side pivoting](https://mui.com/x/react-data-grid/server-side-data/pivoting/) documentation for more details.');
+      }
+
+      // Update the grid state with new columns and column grouping model
+      const partialPropsOverrides = (0, _utils.getPropsOverrides)(response.pivotColumns, pivotingColDef, pivotModel, initialColumns, apiRef);
+      apiRef.current.setState(state => {
+        return (0, _extends2.default)({}, state, {
+          pivoting: (0, _extends2.default)({}, state.pivoting, {
+            propsOverrides: (0, _extends2.default)({}, state.pivoting.propsOverrides, partialPropsOverrides)
+          })
+        });
+      });
+    }
     return {
       params,
       response
     };
-  }, [apiRef]);
+  }, [apiRef, props.pivotingColDef, initialColumns, pivotModel]);
   const resolveGroupAggregation = React.useCallback((groupId, field) => {
     if (groupId === _xDataGridPro.GRID_ROOT_GROUP_ID) {
       return props.dataSource?.getAggregatedValue?.(aggregateRowRef.current, field);
@@ -63,8 +86,10 @@ const useGridDataSourcePremium = (apiRef, props) => {
   Object.entries(events).forEach(([event, handler]) => {
     (0, _xDataGridPro.useGridEvent)(apiRef, event, handler);
   });
-  (0, _xDataGridPro.useGridEvent)(apiRef, 'rowGroupingModelChange', () => debouncedFetchRows());
-  (0, _xDataGridPro.useGridEvent)(apiRef, 'aggregationModelChange', () => debouncedFetchRows());
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'rowGroupingModelChange', (0, _internals.runIf)(!pivotActive, () => debouncedFetchRows()));
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'aggregationModelChange', (0, _internals.runIf)(!pivotActive, () => debouncedFetchRows()));
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'pivotModeChange', (0, _internals.runIf)(!pivotActive, () => debouncedFetchRows()));
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'pivotModelChange', (0, _internals.runIf)(pivotActive, () => debouncedFetchRows()));
   React.useEffect(() => {
     setStrategyAvailability();
   }, [setStrategyAvailability]);

package/hooks/features/dataSource/utils.d.ts

@@ -0,0 +1,6 @@
+import type { RefObject } from '@mui/x-internals/types';
+import { GridColDef } from '@mui/x-data-grid-pro';
+import type { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import type { GridPivotingDynamicPropsOverrides, PivotingColDefCallback, GridPivotModel } from "../pivoting/gridPivotingInterfaces.js";
+import type { GridGetRowsResponsePivotColumn } from "./models.js";
+export declare const getPropsOverrides: (pivotColumns: GridGetRowsResponsePivotColumn[], pivotingColDef: PivotingColDefCallback, pivotModel: GridPivotModel, initialColumns: Map<string, GridColDef>, apiRef: RefObject<GridPrivateApiPremium>) => GridPivotingDynamicPropsOverrides;

package/hooks/features/dataSource/utils.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPropsOverrides = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+const getPropsOverrides = (pivotColumns, pivotingColDef, pivotModel, initialColumns, apiRef) => {
+  const visiblePivotColumns = pivotModel.columns.filter(column => !column.hidden);
+  const visiblePivotValues = pivotModel.values.filter(value => !value.hidden);
+  const columns = Array.from(initialColumns.values());
+
+  // Build column grouping model from pivot column paths
+  const columnGroupingModel = [];
+  const columnGroupingModelLookup = new Map();
+
+  // Build new columns lookup and ordered fields
+  const newColumns = {};
+
+  // Build aggregation model
+  const aggregationModel = {};
+
+  // Create unique combinations of all values from pivotColumns and pivotValues
+  const uniquePaths = [];
+  const processPath = (currentPath, remainingColumns, level) => {
+    if (level === visiblePivotColumns.length) {
+      uniquePaths.push([...currentPath]);
+      return;
+    }
+    remainingColumns.forEach(column => {
+      processPath([...currentPath, {
+        key: column.key,
+        field: visiblePivotColumns[level].field,
+        value: column.group
+      }], column.children || [], level + 1);
+    });
+  };
+  processPath([], pivotColumns, 0);
+
+  /**
+   * Column group headers are sorted by the leaf columns order in the column definition.
+   * Store the values of each column group path to be able to sort them by pivot column sort order.
+   * The values are stored by the column group level which allows easier sorting by going through the column group levels in reverse order.
+   * Store raw value to be able to determine if the value was formatted on the client using `getRowValue`.
+   * Values sent from the server as strings will not be sorted on the client.
+   */
+  const columnGroupPathValues = [];
+  uniquePaths.forEach(columnPath => {
+    const columnPathKeys = columnPath.map(path => path.key);
+    const columnPathValues = columnPath.map(path => path.value);
+    visiblePivotValues.forEach(pivotValue => {
+      // Find the original column definition for the last field
+      const originalColumn = initialColumns.get(pivotValue.field);
+      // get the overrides defined from the data source definition
+      const overrides = pivotingColDef(pivotValue.field, columnPathKeys);
+
+      // Create new column definition based on original column
+      const newColumnDef = (0, _extends2.default)({}, originalColumn, overrides, {
+        aggregable: false,
+        groupable: false,
+        filterable: false,
+        hideable: false,
+        editable: false,
+        disableReorder: true
+      });
+      const pivotFieldName = newColumnDef.field;
+      newColumns[pivotFieldName] = newColumnDef;
+      aggregationModel[pivotFieldName] = pivotValue.aggFunc;
+
+      // Build column grouping model
+      const combinedPathValues = [...columnPathValues, pivotValue.field].map((path, index) => typeof path === 'string' ? path : apiRef.current.getRowValue(path, initialColumns.get(visiblePivotColumns[index].field)));
+      columnGroupPathValues.push({
+        field: pivotFieldName,
+        pathValues: combinedPathValues.slice(0, -1),
+        pathValuesRaw: columnPathValues
+      });
+
+      // Build the hierarchy for column groups
+      for (let i = 0; i < combinedPathValues.length - 1; i += 1) {
+        const currentField = visiblePivotColumns[i].field;
+        const groupPath = combinedPathValues.slice(0, i + 1);
+        const groupId = groupPath.join('-');
+        let headerName = columnPathValues[groupPath.length - 1];
+        if (typeof headerName !== 'string') {
+          headerName = apiRef.current.getRowFormattedValue(headerName, initialColumns.get(currentField));
+        }
+        if (typeof headerName === 'number') {
+          headerName = String(headerName);
+        }
+        if (typeof headerName !== 'string') {
+          throw new Error(`MUI X: Header name for a column group based on ${currentField} cannot be converted to a string.`);
+        }
+        if (!columnGroupingModelLookup.has(groupId)) {
+          const columnGroup = {
+            groupId,
+            headerName,
+            children: []
+          };
+          columnGroupingModelLookup.set(groupId, columnGroup);
+          if (i === 0) {
+            columnGroupingModel.push(columnGroup);
+          } else {
+            const parentGroupId = groupPath.slice(0, -1).join('-');
+            const parentGroup = columnGroupingModelLookup.get(parentGroupId);
+            if (parentGroup) {
+              parentGroup.children.push(columnGroup);
+            }
+          }
+        }
+      }
+
+      // Add the final column to the appropriate group
+      const parentGroupId = combinedPathValues.slice(0, -1).join('-');
+      const parentGroup = columnGroupingModelLookup.get(parentGroupId);
+      if (parentGroup) {
+        parentGroup.children.push({
+          field: pivotFieldName
+        });
+      }
+    });
+  });
+  for (let i = visiblePivotColumns.length - 1; i >= 0; i -= 1) {
+    const sort = visiblePivotColumns[i].sort;
+    if (!sort) {
+      continue;
+    }
+    columnGroupPathValues.sort((a, b) => {
+      // Do not sort values that are returned as strings
+      if (typeof a.pathValuesRaw[i] === 'string' && typeof b.pathValuesRaw[i] === 'string') {
+        return 0;
+      }
+      return (sort === 'asc' ? 1 : -1) * (0, _xDataGridPro.gridStringOrNumberComparator)(a.pathValues[i], b.pathValues[i], {}, {});
+    });
+  }
+  if (visiblePivotColumns.length > 0) {
+    for (let i = 0; i < columnGroupPathValues.length; i += 1) {
+      columns.push(newColumns[columnGroupPathValues[i].field]);
+    }
+  }
+  return {
+    columns,
+    columnGroupingModel,
+    aggregationModel
+  };
+};
+exports.getPropsOverrides = getPropsOverrides;

package/hooks/features/index.d.ts

@@ -3,4 +3,5 @@ export * from "./rowGrouping/index.js";
 export * from "./export/index.js";
 export * from "./cellSelection/index.js";
 export * from "./aiAssistant/index.js";
-export * from "./sidebar/index.js";
+export * from "./sidebar/index.js";
+export * from "./pivoting/index.js";

package/hooks/features/index.js

@@ -68,4 +68,15 @@ Object.keys(_sidebar).forEach(function (key) {
       return _sidebar[key];
     }
   });
+});
+var _pivoting = require("./pivoting");
+Object.keys(_pivoting).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pivoting[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pivoting[key];
+    }
+  });
 });

package/hooks/features/pivoting/gridPivotingInterfaces.d.ts

@@ -3,22 +3,25 @@ import type { GridPivotingPrivateApiCommunity, GridPivotingStatePartial } from '
 import type { RefObject } from '@mui/x-internals/types';
 import type { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
 import type { GridInitialStatePremium } from "../../../models/gridStatePremium.js";
-export type GridPivotingPropsOverrides = {
-  rows: DataGridPremiumProcessedProps['rows'];
+export type GridPivotingStaticPropsOverrides = {
+  rowGroupingModel: DataGridPremiumProcessedProps['rowGroupingModel'];
+  getAggregationPosition: DataGridPremiumProcessedProps['getAggregationPosition'];
+  columnVisibilityModel: DataGridPremiumProcessedProps['columnVisibilityModel'];
+  groupingColDef: DataGridPremiumProcessedProps['groupingColDef'];
+  headerFilters: DataGridPremiumProcessedProps['headerFilters'];
+  disableAggregation: DataGridPremiumProcessedProps['disableAggregation'];
+  disableRowGrouping: DataGridPremiumProcessedProps['disableRowGrouping'];
+};
+export type GridPivotingDynamicPropsOverrides = {
+  rows?: DataGridPremiumProcessedProps['rows'];
   columns: DataGridPremiumProcessedProps['columns'];
-  rowGroupingModel: NonNullable<DataGridPremiumProcessedProps['rowGroupingModel']>;
-  aggregationModel: NonNullable<DataGridPremiumProcessedProps['aggregationModel']>;
-  getAggregationPosition: NonNullable<DataGridPremiumProcessedProps['getAggregationPosition']>;
-  columnVisibilityModel: NonNullable<DataGridPremiumProcessedProps['columnVisibilityModel']>;
-  columnGroupingModel: NonNullable<DataGridPremiumProcessedProps['columnGroupingModel']>;
-  groupingColDef: NonNullable<DataGridPremiumProcessedProps['groupingColDef']>;
-  headerFilters: NonNullable<DataGridPremiumProcessedProps['headerFilters']>;
-  disableAggregation: NonNullable<DataGridPremiumProcessedProps['disableAggregation']>;
-  disableRowGrouping: NonNullable<DataGridPremiumProcessedProps['disableRowGrouping']>;
+  aggregationModel: DataGridPremiumProcessedProps['aggregationModel'];
+  columnGroupingModel: DataGridPremiumProcessedProps['columnGroupingModel'];
 };
+export type GridPivotingPropsOverrides = GridPivotingStaticPropsOverrides & GridPivotingDynamicPropsOverrides;
 export interface GridPivotingState extends GridPivotingStatePartial {
   model: GridPivotModel;
-  propsOverrides: GridPivotingPropsOverrides | undefined;
+  propsOverrides: GridPivotingPropsOverrides | GridPivotingStaticPropsOverrides | {} | undefined;
 }
 export interface GridPivotingInitialState {
   model?: GridPivotModel;
@@ -73,7 +76,14 @@ export interface GridPivotingPrivateApi extends GridPivotingPrivateApiCommunity
     targetFieldPosition?: DropPosition;
   }) => void;
 }
-export type GridPivotingColDefOverrides = Pick<GridColDef, 'width' | 'flex' | 'headerName' | 'description' | 'align' | 'headerAlign' | 'cellClassName' | 'headerClassName' | 'display' | 'maxWidth' | 'minWidth' | 'resizable' | 'sortingOrder'>;
+export type GridPivotingColDefOverrides = Pick<GridColDef, 'field' | 'width' | 'flex' | 'headerName' | 'description' | 'align' | 'headerAlign' | 'cellClassName' | 'headerClassName' | 'display' | 'maxWidth' | 'minWidth' | 'resizable' | 'sortingOrder'>;
+/**
+ * The column definition overrides callback for the columns generated by the pivoting feature.
+ * @param {string} originalColumnField The field of the original column.
+ * @param {string[]} columnGroupPath The path of the column groups the column belongs to.
+ * @returns {Partial<GridPivotingColDefOverrides> | undefined | void} The column definition overrides.
+ */
+export type PivotingColDefCallback = (originalColumnField: GridColDef['field'], columnGroupPath: string[]) => Partial<GridPivotingColDefOverrides> | undefined;
 export interface GridPivotingInternalCache {
   nonPivotDataRef: RefObject<{
     rows: GridRowModel[];

package/hooks/features/pivoting/gridPivotingSelectors.d.ts

@@ -7,5 +7,5 @@ export declare const gridPivotModelSelector: (args_0: import("react").RefObject<
 } | null>) => import("./gridPivotingInterfaces.js").GridPivotModel;
 export declare const gridPivotPropsOverridesSelector: (args_0: import("react").RefObject<{
   state: GridStatePremium;
-} | null>) => import("./gridPivotingInterfaces.js").GridPivotingPropsOverrides | undefined;
+} | null>) => {} | undefined;
 export { gridPivotActiveSelector, gridPivotInitialColumnsSelector } from '@mui/x-data-grid/internals';

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

@@ -0,0 +1 @@
+export { gridPivotModelSelector } from "./gridPivotingSelectors.js";

package/hooks/features/pivoting/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "gridPivotModelSelector", {
+  enumerable: true,
+  get: function () {
+    return _gridPivotingSelectors.gridPivotModelSelector;
+  }
+});
+var _gridPivotingSelectors = require("./gridPivotingSelectors");

package/hooks/features/pivoting/useGridPivoting.d.ts

@@ -4,5 +4,5 @@ import { GridStateInitializer } from '@mui/x-data-grid-pro/internals';
 import type { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
 import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
 export declare const pivotingStateInitializer: GridStateInitializer<Pick<DataGridPremiumProcessedProps, 'pivotActive' | 'pivotModel' | 'pivotPanelOpen' | 'initialState' | 'disablePivoting' | 'getPivotDerivedColumns' | 'columns'>, GridPrivateApiPremium>;
-export declare const useGridPivoting: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "pivotActive" | "onPivotActiveChange" | "pivotModel" | "onPivotModelChange" | "pivotPanelOpen" | "onPivotPanelOpenChange" | "disablePivoting" | "getPivotDerivedColumns" | "pivotingColDef" | "groupingColDef" | "aggregationFunctions">, originalColumnsProp: readonly GridColDef[], originalRowsProp: readonly GridRowModel[]) => void;
+export declare const useGridPivoting: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "pivotActive" | "onPivotActiveChange" | "pivotModel" | "onPivotModelChange" | "pivotPanelOpen" | "onPivotPanelOpenChange" | "disablePivoting" | "getPivotDerivedColumns" | "pivotingColDef" | "groupingColDef" | "aggregationFunctions" | "loading" | "dataSource">, originalColumnsProp: readonly GridColDef[], originalRowsProp: readonly GridRowModel[]) => void;
 export declare const useGridPivotingExportState: (apiRef: RefObject<GridPrivateApiPremium>) => void;