@mui/x-data-grid-premium 8.0.0-beta.2 → 8.0.0

package/hooks/features/aiAssistant/useGridAiAssistant.js

@@ -0,0 +1,303 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridAiAssistant = exports.aiAssistantStateInitializer = void 0;
+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 _gridAiAssistantSelectors = require("./gridAiAssistantSelectors");
+var _jsxRuntime = require("react/jsx-runtime");
+const DEFAULT_SAMPLE_COUNT = 5;
+const aiAssistantStateInitializer = (state, props) => {
+  if (!props.aiAssistant) {
+    return (0, _extends2.default)({}, state, {
+      aiAssistant: {
+        activeConversationIndex: 0,
+        conversations: []
+      }
+    });
+  }
+  return (0, _extends2.default)({}, state, {
+    aiAssistant: {
+      activeConversationIndex: 0,
+      conversations: props.aiAssistantConversations ?? props.initialState?.aiAssistant?.conversations ?? []
+    }
+  });
+};
+exports.aiAssistantStateInitializer = aiAssistantStateInitializer;
+const useGridAiAssistant = (apiRef, props) => {
+  const {
+    onPrompt,
+    allowAiAssistantDataSampling,
+    slots,
+    disableColumnFilter,
+    disableRowGrouping,
+    disableAggregation,
+    disableColumnSorting,
+    disablePivoting
+  } = props;
+  const columnsLookup = (0, _xDataGridPro.gridColumnLookupSelector)(apiRef);
+  const columns = Object.values(columnsLookup);
+  const rows = Object.values((0, _xDataGridPro.gridRowsLookupSelector)(apiRef));
+  const isAiAssistantAvailable = !!props.aiAssistant;
+  apiRef.current.registerControlState({
+    stateId: 'aiAssistantConversations',
+    propModel: props.aiAssistantConversations,
+    propOnChange: props.onAiAssistantConversationsChange,
+    stateSelector: _gridAiAssistantSelectors.gridAiAssistantConversationsSelector,
+    changeEvent: 'aiAssistantConversationsChange'
+  });
+  apiRef.current.registerControlState({
+    stateId: 'aiAssistantActiveConversationIndex',
+    propModel: props.aiAssistantActiveConversationIndex,
+    propOnChange: props.onAiAssistantActiveConversationIndexChange,
+    stateSelector: _gridAiAssistantSelectors.gridAiAssistantActiveConversationIndexSelector,
+    changeEvent: 'aiAssistantActiveConversationIndexChange'
+  });
+  const preferencePanelPreProcessing = React.useCallback((initialValue, value) => {
+    if (isAiAssistantAvailable && slots.aiAssistantPanel && value === _xDataGridPro.GridPreferencePanelsValue.aiAssistant) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(slots.aiAssistantPanel, {});
+    }
+    return initialValue;
+  }, [isAiAssistantAvailable, slots]);
+  const collectSampleData = React.useCallback(() => {
+    const columnExamples = {};
+    columns.forEach(column => {
+      columnExamples[column.field] = Array.from({
+        length: Math.min(DEFAULT_SAMPLE_COUNT, rows.length)
+      }).map(() => {
+        const row = rows[Math.floor(Math.random() * rows.length)];
+        if (column.valueGetter) {
+          return column.valueGetter(row[column.field], row, column, apiRef);
+        }
+        return row[column.field];
+      });
+    });
+    return columnExamples;
+  }, [apiRef, columns, rows]);
+  const getPromptContext = React.useCallback((allowDataSampling = false) => {
+    if (!isAiAssistantAvailable) {
+      return '';
+    }
+    const examples = allowDataSampling ? collectSampleData() : {};
+    const columnsContext = columns.map(column => ({
+      field: column.field,
+      description: column.description ?? null,
+      examples: examples[column.field] ?? column.examples ?? [],
+      type: column.type ?? 'string',
+      allowedOperators: column.filterOperators?.map(operator => operator.value) ?? []
+    }));
+    return JSON.stringify(columnsContext);
+  }, [columns, collectSampleData, isAiAssistantAvailable]);
+  const applyPromptResult = React.useCallback(result => {
+    if (!isAiAssistantAvailable) {
+      return;
+    }
+    const interestColumns = [];
+    if (!disableColumnFilter) {
+      apiRef.current.setFilterModel({
+        items: result.filters.map((filter, index) => {
+          const item = {
+            id: index,
+            field: filter.column,
+            operator: filter.operator,
+            value: filter.value
+          };
+          const column = columnsLookup[filter.column];
+          if (column.type === 'singleSelect') {
+            const options = (0, _internals.getValueOptions)(column) ?? [];
+            const found = options.find(option => typeof option === 'object' && option.label === filter.value);
+            if (found) {
+              item.value = found.value;
+            }
+          }
+          return item;
+        }),
+        logicOperator: result.filterOperator ?? _xDataGridPro.GridLogicOperator.And,
+        quickFilterValues: []
+      });
+      interestColumns.push(...result.filters.map(f => f.column));
+    }
+    let appliedPivoting = false;
+    if (!disablePivoting && 'columns' in result.pivoting) {
+      apiRef.current.setPivotActive(true);
+      apiRef.current.setPivotModel({
+        columns: result.pivoting.columns.map(c => ({
+          field: c.column,
+          sort: c.direction
+        })),
+        rows: result.pivoting.rows.map(r => ({
+          field: r
+        })),
+        values: result.pivoting.values.map(valueObj => {
+          const [field] = Object.keys(valueObj);
+          return {
+            field,
+            aggFunc: valueObj[field]
+          };
+        })
+      });
+      appliedPivoting = true;
+    } else if ('columns' in result.pivoting) {
+      // if pivoting is disabled and there are pivoting results, try to move them into grouping and aggregation
+      result.pivoting.columns.forEach(c => {
+        result.grouping.push({
+          column: c.column
+        });
+      });
+      result.pivoting.rows.forEach(r => {
+        result.grouping.push({
+          column: r
+        });
+      });
+      result.pivoting.values.forEach(valueObj => {
+        const [field] = Object.keys(valueObj);
+        result.aggregation[field] = valueObj[field];
+      });
+      // remove the pivoting results data
+      result.pivoting = {};
+    }
+    if (!disableRowGrouping && !appliedPivoting) {
+      apiRef.current.setRowGroupingModel(result.grouping.map(g => g.column));
+    }
+    if (!disableAggregation && !appliedPivoting) {
+      apiRef.current.setAggregationModel(result.aggregation);
+      interestColumns.push(...Object.keys(result.aggregation));
+    }
+    if (!disableColumnSorting) {
+      apiRef.current.setSortModel(result.sorting.map(s => ({
+        field: s.column,
+        sort: s.direction
+      })));
+    }
+    const visibleRowsData = (0, _internals.getVisibleRows)(apiRef);
+    const rowSelectionModel = {
+      type: 'include',
+      ids: new Set()
+    };
+    if (result.select !== -1) {
+      for (let i = 0; i < result.select; i += 1) {
+        const row = visibleRowsData.rows[i];
+        const id = apiRef.current.getRowId(row);
+        rowSelectionModel.ids.add(id);
+      }
+    }
+    apiRef.current.setRowSelectionModel(rowSelectionModel);
+    const targetIndex = Number(columnsLookup[_xDataGridPro.GRID_CHECKBOX_SELECTION_FIELD] !== undefined) + Number(result.grouping.length);
+    interestColumns.reverse().forEach(c => apiRef.current.setColumnIndex(c, targetIndex));
+  }, [apiRef, disableColumnFilter, disableRowGrouping, disableAggregation, disableColumnSorting, disablePivoting, columnsLookup, isAiAssistantAvailable]);
+  const setActiveConversationId = React.useCallback(id => {
+    if (!isAiAssistantAvailable) {
+      return;
+    }
+    const conversations = (0, _gridAiAssistantSelectors.gridAiAssistantConversationsSelector)(apiRef);
+    const activeConversationIndex = (0, _gridAiAssistantSelectors.gridAiAssistantActiveConversationIndexSelector)(apiRef);
+    if (!conversations[activeConversationIndex]) {
+      return;
+    }
+    conversations[activeConversationIndex].id = id;
+    apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+      aiAssistant: (0, _extends2.default)({}, state.aiAssistant, {
+        conversations
+      })
+    }));
+  }, [apiRef, isAiAssistantAvailable]);
+  const setConversationPrompts = React.useCallback((index, callback) => {
+    if (!isAiAssistantAvailable) {
+      return;
+    }
+    const currentConversations = (0, _gridAiAssistantSelectors.gridAiAssistantConversationsSelector)(apiRef);
+    const targetConversation = currentConversations[index];
+    const newPrompts = typeof callback === 'function' ? callback(targetConversation === undefined ? [] : targetConversation.prompts) : callback;
+    const newConversations = currentConversations.toSpliced(targetConversation === undefined ? currentConversations.length : index, 1, (0, _extends2.default)({}, targetConversation, {
+      title: newPrompts[newPrompts.length - 1].value,
+      // TODO: make the title configurable
+      prompts: newPrompts
+    }));
+    apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+      aiAssistant: (0, _extends2.default)({}, state.aiAssistant, {
+        conversations: newConversations
+      })
+    }));
+  }, [apiRef, isAiAssistantAvailable]);
+  const processPrompt = React.useCallback(async value => {
+    if (!onPrompt) {
+      return undefined;
+    }
+    const activeConversationIndex = (0, _gridAiAssistantSelectors.gridAiAssistantActiveConversationIndexSelector)(apiRef);
+    const activeConversation = (0, _gridAiAssistantSelectors.gridAiAssistantActiveConversationSelector)(apiRef);
+    const date = Date.now();
+    apiRef.current.setLoading(true);
+    setConversationPrompts(activeConversationIndex, prevPrompts => [...prevPrompts, {
+      value,
+      createdAt: new Date(date),
+      variant: 'processing',
+      helperText: apiRef.current.getLocaleText('promptProcessing')
+    }]);
+    try {
+      const response = await onPrompt(value, getPromptContext(allowAiAssistantDataSampling), activeConversation?.id);
+      applyPromptResult(response);
+      setActiveConversationId(response.conversationId);
+      setConversationPrompts(activeConversationIndex, prevPrompts => prevPrompts.map(item => item.createdAt.getTime() === date ? (0, _extends2.default)({}, item, {
+        response,
+        variant: 'success',
+        helperText: ''
+      }) : item));
+      return response;
+    } catch (error) {
+      setConversationPrompts(activeConversationIndex, prevPrompts => prevPrompts.map(item => item.createdAt.getTime() === date ? (0, _extends2.default)({}, item, {
+        variant: 'error',
+        helperText: error.message
+      }) : item));
+      return error;
+    } finally {
+      apiRef.current.setLoading(false);
+    }
+  }, [apiRef, allowAiAssistantDataSampling, onPrompt, getPromptContext, applyPromptResult, setConversationPrompts, setActiveConversationId]);
+  const setActiveConversationIndex = React.useCallback(index => {
+    apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+      aiAssistant: (0, _extends2.default)({}, state.aiAssistant, {
+        activeConversationIndex: index
+      })
+    }));
+    const conversation = (0, _gridAiAssistantSelectors.gridAiAssistantActiveConversationSelector)(apiRef);
+    if (!conversation) {
+      throw new Error('Conversation not found');
+    }
+    return conversation;
+  }, [apiRef]);
+  const setConversations = React.useCallback(callback => {
+    if (!isAiAssistantAvailable) {
+      return;
+    }
+    apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+      aiAssistant: (0, _extends2.default)({}, state.aiAssistant, {
+        conversations: typeof callback === 'function' ? callback(state.aiAssistant?.conversations) : callback
+      })
+    }));
+  }, [apiRef, isAiAssistantAvailable]);
+  React.useEffect(() => {
+    if (props.aiAssistantConversations) {
+      setConversations(props.aiAssistantConversations);
+    }
+  }, [apiRef, props.aiAssistantConversations, setConversations]);
+  React.useEffect(() => {
+    if (props.aiAssistantActiveConversationIndex) {
+      setActiveConversationIndex(props.aiAssistantActiveConversationIndex);
+    }
+  }, [apiRef, props.aiAssistantActiveConversationIndex, setActiveConversationIndex]);
+  (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'preferencePanel', preferencePanelPreProcessing);
+  (0, _xDataGridPro.useGridApiMethod)(apiRef, {
+    aiAssistant: {
+      processPrompt,
+      setConversations,
+      setActiveConversationIndex
+    }
+  }, 'public');
+};
+exports.useGridAiAssistant = useGridAiAssistant;

package/hooks/features/cellSelection/useGridCellSelection.js

@@ -363,11 +363,11 @@ const useGridCellSelection = (apiRef, props) => {
       field
     }, cellWithVirtualFocus.current);
   });
-  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'cellClick', runIfCellSelectionIsEnabled(handleCellClick));
-  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'cellFocusIn', runIfCellSelectionIsEnabled(handleCellFocusIn));
-  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'cellKeyDown', runIfCellSelectionIsEnabled(handleCellKeyDown));
-  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'cellMouseDown', runIfCellSelectionIsEnabled(handleCellMouseDown));
-  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'cellMouseOver', runIfCellSelectionIsEnabled(handleCellMouseOver));
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'cellClick', runIfCellSelectionIsEnabled(handleCellClick));
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'cellFocusIn', runIfCellSelectionIsEnabled(handleCellFocusIn));
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'cellKeyDown', runIfCellSelectionIsEnabled(handleCellKeyDown));
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'cellMouseDown', runIfCellSelectionIsEnabled(handleCellMouseDown));
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'cellMouseOver', runIfCellSelectionIsEnabled(handleCellMouseOver));
   React.useEffect(() => {
     if (props.cellSelectionModel) {
       apiRef.current.setCellSelectionModel(props.cellSelectionModel);

package/hooks/features/clipboard/useGridClipboardImport.js

@@ -336,9 +336,9 @@ const useGridClipboardImport = (apiRef, props) => {
     }
     return initialValue;
   }, [enableClipboardPaste]);
-  (0, _xDataGrid.useGridApiEventHandler)(apiRef, 'cellKeyDown', handlePaste);
-  (0, _xDataGrid.useGridApiOptionHandler)(apiRef, 'clipboardPasteStart', props.onClipboardPasteStart);
-  (0, _xDataGrid.useGridApiOptionHandler)(apiRef, 'clipboardPasteEnd', props.onClipboardPasteEnd);
+  (0, _xDataGrid.useGridEvent)(apiRef, 'cellKeyDown', handlePaste);
+  (0, _xDataGrid.useGridEventPriority)(apiRef, 'clipboardPasteStart', props.onClipboardPasteStart);
+  (0, _xDataGrid.useGridEventPriority)(apiRef, 'clipboardPasteEnd', props.onClipboardPasteEnd);
   (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'canStartEditing', checkIfCanStartEditing);
 };
 exports.useGridClipboardImport = useGridClipboardImport;

package/hooks/features/dataSource/useGridDataSourcePremium.js

@@ -21,6 +21,7 @@ const options = {
 const useGridDataSourcePremium = (apiRef, props) => {
   const {
     api,
+    debouncedFetchRows,
     strategyProcessor,
     events,
     setStrategyAvailability
@@ -59,8 +60,10 @@ const useGridDataSourcePremium = (apiRef, props) => {
   (0, _internals.useGridRegisterStrategyProcessor)(apiRef, strategyProcessor.strategyName, strategyProcessor.group, strategyProcessor.processor);
   (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'processDataSourceRows', processDataSourceRows);
   Object.entries(events).forEach(([event, handler]) => {
-    (0, _xDataGridPro.useGridApiEventHandler)(apiRef, event, handler);
+    (0, _xDataGridPro.useGridEvent)(apiRef, event, handler);
   });
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'rowGroupingModelChange', () => debouncedFetchRows());
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'aggregationModelChange', () => debouncedFetchRows());
   React.useEffect(() => {
     setStrategyAvailability();
   }, [setStrategyAvailability]);

package/hooks/features/export/useGridExcelExport.js

@@ -143,6 +143,6 @@ const useGridExcelExport = (apiRef, props) => {
     }];
   }, []);
   (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'exportMenu', addExportMenuButtons);
-  (0, _xDataGrid.useGridApiOptionHandler)(apiRef, 'excelExportStateChange', props.onExcelExportStateChange);
+  (0, _xDataGrid.useGridEventPriority)(apiRef, 'excelExportStateChange', props.onExcelExportStateChange);
 };
 exports.useGridExcelExport = useGridExcelExport;

package/hooks/features/index.d.ts

@@ -2,4 +2,4 @@ export * from "./aggregation/index.js";
 export * from "./rowGrouping/index.js";
 export * from "./export/index.js";
 export * from "./cellSelection/index.js";
-export * from "./promptControl/index.js";
+export * from "./aiAssistant/index.js";

package/hooks/features/index.js

@@ -47,14 +47,14 @@ Object.keys(_cellSelection).forEach(function (key) {
     }
   });
 });
-var _promptControl = require("./promptControl");
-Object.keys(_promptControl).forEach(function (key) {
+var _aiAssistant = require("./aiAssistant");
+Object.keys(_aiAssistant).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _promptControl[key]) return;
+  if (key in exports && exports[key] === _aiAssistant[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _promptControl[key];
+      return _aiAssistant[key];
     }
   });
 });

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

@@ -0,0 +1,69 @@
+import type { GridColDef } from '@mui/x-data-grid-pro';
+import type { GridPivotingPrivateApiCommunity, GridPivotingStatePartial } from '@mui/x-data-grid/internals';
+import type { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
+export type GridPivotingPropsOverrides = {
+  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']>;
+};
+export interface GridPivotingState extends GridPivotingStatePartial {
+  model: GridPivotModel;
+  propsOverrides: GridPivotingPropsOverrides | undefined;
+}
+export interface GridPivotingInitialState {
+  model?: GridPivotModel;
+  enabled?: boolean;
+  panelOpen?: boolean;
+}
+export interface GridPivotModel {
+  columns: {
+    field: GridColDef['field'];
+    sort?: 'asc' | 'desc';
+    hidden?: boolean;
+  }[];
+  rows: {
+    field: GridColDef['field'];
+    hidden?: boolean;
+  }[];
+  values: {
+    field: GridColDef['field'];
+    aggFunc: string;
+    hidden?: boolean;
+  }[];
+}
+export type DropPosition = 'top' | 'bottom' | null;
+export interface GridPivotingApi {
+  /**
+   * Sets the pivot model to use in the pivot mode.
+   * @param {GridPivotModel | ((prev: GridPivotModel) => GridPivotModel)} model - The pivot model to set.
+   */
+  setPivotModel: (model: GridPivotModel | ((prev: GridPivotModel) => GridPivotModel)) => void;
+  /**
+   * Sets whether the pivot mode is active.
+   * @param {boolean | ((prev: boolean) => boolean)} active - The new value of the pivot mode state.
+   */
+  setPivotActive: (active: boolean | ((prev: boolean) => boolean)) => void;
+  /**
+   * Sets whether the pivot panel is open.
+   * @param {boolean | ((prev: boolean) => boolean)} open - The new value of the pivot panel open state.
+   */
+  setPivotPanelOpen: (open: boolean | ((prev: boolean) => boolean)) => void;
+}
+export interface GridPivotingPrivateApi extends GridPivotingPrivateApiCommunity {
+  updatePivotModel: (params: {
+    field: string;
+    targetSection: 'columns' | 'rows' | 'values' | null;
+    originSection: 'columns' | 'rows' | 'values' | null;
+    targetField?: string;
+    targetFieldPosition?: DropPosition;
+  }) => void;
+}
+export type GridPivotingColDefOverrides = Pick<GridColDef, 'width' | 'flex' | 'headerName' | 'description' | 'align' | 'headerAlign' | 'cellClassName' | 'headerClassName' | 'display' | 'maxWidth' | 'minWidth' | 'resizable' | 'sortingOrder'>;

package/hooks/features/pivoting/gridPivotingInterfaces.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -0,0 +1,4 @@
+import type { GridStatePremium } from '../../../models/gridStatePremium';
+export declare const gridPivotModelSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridPivotingInterfaces").GridPivotingState, import("./gridPivotingInterfaces").GridPivotModel>;
+export declare const gridPivotPropsOverridesSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridPivotingInterfaces").GridPivotingState, import("./gridPivotingInterfaces").GridPivotingPropsOverrides | undefined>;
+export { gridPivotActiveSelector, gridPivotInitialColumnsSelector, gridPivotPanelOpenSelector } from '@mui/x-data-grid/internals';

package/hooks/features/pivoting/gridPivotingSelectors.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "gridPivotActiveSelector", {
+  enumerable: true,
+  get: function () {
+    return _internals2.gridPivotActiveSelector;
+  }
+});
+Object.defineProperty(exports, "gridPivotInitialColumnsSelector", {
+  enumerable: true,
+  get: function () {
+    return _internals2.gridPivotInitialColumnsSelector;
+  }
+});
+exports.gridPivotModelSelector = void 0;
+Object.defineProperty(exports, "gridPivotPanelOpenSelector", {
+  enumerable: true,
+  get: function () {
+    return _internals2.gridPivotPanelOpenSelector;
+  }
+});
+exports.gridPivotPropsOverridesSelector = void 0;
+var _internals = require("@mui/x-data-grid-pro/internals");
+var _internals2 = require("@mui/x-data-grid/internals");
+const gridPivotingStateSelector = (0, _internals.createRootSelector)(state => state.pivoting);
+const gridPivotModelSelector = exports.gridPivotModelSelector = (0, _internals.createSelector)(gridPivotingStateSelector, pivoting => pivoting?.model);
+const gridPivotPropsOverridesSelector = exports.gridPivotPropsOverridesSelector = (0, _internals.createSelector)(gridPivotingStateSelector, pivoting => pivoting?.active ? pivoting.propsOverrides : undefined);

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

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