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

package/esm/hooks/features/aiAssistant/gridAiAssistantInterfaces.d.ts

@@ -0,0 +1,82 @@
+export type Prompt = {
+  value: string;
+  createdAt: Date;
+  response?: PromptResponse;
+  variant?: 'success' | 'error' | 'processing';
+  helperText?: string;
+};
+export type PromptSuggestion = {
+  value: string;
+};
+export type Conversation = {
+  id?: string;
+  title?: string;
+  prompts: Prompt[];
+};
+export type GridAiAssistantState = {
+  activeConversationIndex: number;
+  conversations: Conversation[];
+};
+export type GridAiAssistantInitialState = Partial<GridAiAssistantState>;
+type ColumnSort = {
+  column: string;
+  direction: 'asc' | 'desc';
+};
+type ColumnFilter = {
+  operator: string;
+  value: string | number | boolean | string[] | number[];
+  column: string;
+};
+type Grouping = {
+  column: string;
+};
+type AggregationFunction = 'avg' | 'sum' | 'min' | 'max' | 'size';
+type Aggregation = {
+  [column: string]: AggregationFunction;
+};
+type Pivoting = {
+  columns: ColumnSort[];
+  rows: string[];
+  values: Aggregation[];
+} | {};
+export type PromptResponse = {
+  conversationId: string;
+  select: number;
+  filters: ColumnFilter[];
+  filterOperator?: 'and' | 'or';
+  aggregation: Aggregation;
+  sorting: ColumnSort[];
+  grouping: Grouping[];
+  pivoting: Pivoting;
+};
+/**
+ * The prompt API interface that is available in the grid [[apiRef]].
+ */
+export interface GridAiAssistantApi {
+  /**
+   * The AI assistant API.
+   */
+  aiAssistant: {
+    /**
+     * Calls the `onPrompt()` callback to evaluate the prompt and get the necessary updates to the grid state.
+     * Adds the prompt to the current conversation.
+     * Updates the grid state based on the prompt response.
+     * @param {string} value The prompt to process
+     * @returns {Promise<PromptResponse | Error>} The grid state updates or a processing error
+     */
+    processPrompt: (value: string) => Promise<PromptResponse | Error>;
+    /**
+     * Sets the conversations.
+     * @param {Conversation[] | ((prevConversations: Conversation[]) => Conversation[])} conversations The new conversations.
+     */
+    setConversations: (conversations: Conversation[] | ((prevConversations: Conversation[]) => Conversation[])) => void;
+    /**
+     * Sets the active conversation index.
+     * @param {number} index The index of the conversation that should become active.
+     * @returns {Conversation} The active conversation.
+     * @throws {Error} If the conversation index does not exist.
+     */
+    setActiveConversationIndex: (index: number) => Conversation;
+  };
+}
+export {};

package/esm/hooks/features/aiAssistant/gridAiAssistantSelectors.d.ts

@@ -0,0 +1,5 @@
+import type { GridStatePremium } from '../../../models/gridStatePremium';
+import { Conversation } from "./gridAiAssistantInterfaces.js";
+export declare const gridAiAssistantActiveConversationIndexSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridAiAssistantInterfaces").GridAiAssistantState, number>;
+export declare const gridAiAssistantConversationsSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridAiAssistantInterfaces").GridAiAssistantState, Conversation[]>;
+export declare const gridAiAssistantActiveConversationSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, number, Conversation | undefined>;

package/esm/hooks/features/aiAssistant/gridAiAssistantSelectors.js

@@ -0,0 +1,5 @@
+import { createSelector, createRootSelector, createSelectorMemoized } from '@mui/x-data-grid-pro/internals';
+const gridAiAssistantStateSelector = createRootSelector(state => state.aiAssistant);
+export const gridAiAssistantActiveConversationIndexSelector = createSelector(gridAiAssistantStateSelector, aiAssistant => aiAssistant?.activeConversationIndex);
+export const gridAiAssistantConversationsSelector = createSelector(gridAiAssistantStateSelector, aiAssistant => aiAssistant?.conversations);
+export const gridAiAssistantActiveConversationSelector = createSelectorMemoized(gridAiAssistantConversationsSelector, gridAiAssistantActiveConversationIndexSelector, (conversations, index) => conversations[index]);

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

@@ -0,0 +1,2 @@
+export { gridDefaultPromptResolver as unstable_gridDefaultPromptResolver } from "./api.js";
+export type { PromptResponse, Conversation, PromptSuggestion } from './gridAiAssistantInterfaces';

package/esm/hooks/features/aiAssistant/useGridAiAssistant.d.ts

@@ -0,0 +1,6 @@
+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 aiAssistantStateInitializer: GridStateInitializer<Pick<DataGridPremiumProcessedProps, 'initialState' | 'aiAssistantConversations' | 'aiAssistant'>>;
+export declare const useGridAiAssistant: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "aiAssistant" | "aiAssistantConversations" | "aiAssistantActiveConversationIndex" | "allowAiAssistantDataSampling" | "onAiAssistantConversationsChange" | "onAiAssistantActiveConversationIndexChange" | "onPrompt" | "slots" | "disableColumnFilter" | "disableRowGrouping" | "disableAggregation" | "disableColumnSorting" | "disablePivoting">) => void;

package/esm/hooks/features/aiAssistant/useGridAiAssistant.js

@@ -0,0 +1,293 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { gridColumnLookupSelector, GridLogicOperator, gridRowsLookupSelector, useGridApiMethod, GRID_CHECKBOX_SELECTION_FIELD, GridPreferencePanelsValue } from '@mui/x-data-grid-pro';
+import { getValueOptions, getVisibleRows, useGridRegisterPipeProcessor } from '@mui/x-data-grid-pro/internals';
+import { gridAiAssistantConversationsSelector, gridAiAssistantActiveConversationSelector, gridAiAssistantActiveConversationIndexSelector } from "./gridAiAssistantSelectors.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const DEFAULT_SAMPLE_COUNT = 5;
+export const aiAssistantStateInitializer = (state, props) => {
+  if (!props.aiAssistant) {
+    return _extends({}, state, {
+      aiAssistant: {
+        activeConversationIndex: 0,
+        conversations: []
+      }
+    });
+  }
+  return _extends({}, state, {
+    aiAssistant: {
+      activeConversationIndex: 0,
+      conversations: props.aiAssistantConversations ?? props.initialState?.aiAssistant?.conversations ?? []
+    }
+  });
+};
+export const useGridAiAssistant = (apiRef, props) => {
+  const {
+    onPrompt,
+    allowAiAssistantDataSampling,
+    slots,
+    disableColumnFilter,
+    disableRowGrouping,
+    disableAggregation,
+    disableColumnSorting,
+    disablePivoting
+  } = props;
+  const columnsLookup = gridColumnLookupSelector(apiRef);
+  const columns = Object.values(columnsLookup);
+  const rows = Object.values(gridRowsLookupSelector(apiRef));
+  const isAiAssistantAvailable = !!props.aiAssistant;
+  apiRef.current.registerControlState({
+    stateId: 'aiAssistantConversations',
+    propModel: props.aiAssistantConversations,
+    propOnChange: props.onAiAssistantConversationsChange,
+    stateSelector: gridAiAssistantConversationsSelector,
+    changeEvent: 'aiAssistantConversationsChange'
+  });
+  apiRef.current.registerControlState({
+    stateId: 'aiAssistantActiveConversationIndex',
+    propModel: props.aiAssistantActiveConversationIndex,
+    propOnChange: props.onAiAssistantActiveConversationIndexChange,
+    stateSelector: gridAiAssistantActiveConversationIndexSelector,
+    changeEvent: 'aiAssistantActiveConversationIndexChange'
+  });
+  const preferencePanelPreProcessing = React.useCallback((initialValue, value) => {
+    if (isAiAssistantAvailable && slots.aiAssistantPanel && value === GridPreferencePanelsValue.aiAssistant) {
+      return /*#__PURE__*/_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 = 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 ?? 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 = 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[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 = gridAiAssistantConversationsSelector(apiRef);
+    const activeConversationIndex = gridAiAssistantActiveConversationIndexSelector(apiRef);
+    if (!conversations[activeConversationIndex]) {
+      return;
+    }
+    conversations[activeConversationIndex].id = id;
+    apiRef.current.setState(state => _extends({}, state, {
+      aiAssistant: _extends({}, state.aiAssistant, {
+        conversations
+      })
+    }));
+  }, [apiRef, isAiAssistantAvailable]);
+  const setConversationPrompts = React.useCallback((index, callback) => {
+    if (!isAiAssistantAvailable) {
+      return;
+    }
+    const currentConversations = 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, _extends({}, targetConversation, {
+      title: newPrompts[newPrompts.length - 1].value,
+      // TODO: make the title configurable
+      prompts: newPrompts
+    }));
+    apiRef.current.setState(state => _extends({}, state, {
+      aiAssistant: _extends({}, state.aiAssistant, {
+        conversations: newConversations
+      })
+    }));
+  }, [apiRef, isAiAssistantAvailable]);
+  const processPrompt = React.useCallback(async value => {
+    if (!onPrompt) {
+      return undefined;
+    }
+    const activeConversationIndex = gridAiAssistantActiveConversationIndexSelector(apiRef);
+    const activeConversation = 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 ? _extends({}, item, {
+        response,
+        variant: 'success',
+        helperText: ''
+      }) : item));
+      return response;
+    } catch (error) {
+      setConversationPrompts(activeConversationIndex, prevPrompts => prevPrompts.map(item => item.createdAt.getTime() === date ? _extends({}, 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 => _extends({}, state, {
+      aiAssistant: _extends({}, state.aiAssistant, {
+        activeConversationIndex: index
+      })
+    }));
+    const conversation = 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 => _extends({}, state, {
+      aiAssistant: _extends({}, 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]);
+  useGridRegisterPipeProcessor(apiRef, 'preferencePanel', preferencePanelPreProcessing);
+  useGridApiMethod(apiRef, {
+    aiAssistant: {
+      processPrompt,
+      setConversations,
+      setActiveConversationIndex
+    }
+  }, 'public');
+};

package/esm/hooks/features/cellSelection/useGridCellSelection.js

@@ -3,7 +3,7 @@ import * as React from 'react';
 import ownerDocument from '@mui/utils/ownerDocument';
 import useEventCallback from '@mui/utils/useEventCallback';
 import { getTotalHeaderHeight, getVisibleRows, isNavigationKey, serializeCellValue, useGridRegisterPipeProcessor } from '@mui/x-data-grid-pro/internals';
-import { useGridApiEventHandler, useGridApiMethod, GRID_ACTIONS_COLUMN_TYPE, GRID_CHECKBOX_SELECTION_COL_DEF, GRID_DETAIL_PANEL_TOGGLE_FIELD, gridClasses, gridFocusCellSelector, GRID_REORDER_COL_DEF, gridSortedRowIdsSelector, gridDimensionsSelector } from '@mui/x-data-grid-pro';
+import { useGridEvent, useGridApiMethod, GRID_ACTIONS_COLUMN_TYPE, GRID_CHECKBOX_SELECTION_COL_DEF, GRID_DETAIL_PANEL_TOGGLE_FIELD, gridClasses, gridFocusCellSelector, GRID_REORDER_COL_DEF, gridSortedRowIdsSelector, gridDimensionsSelector } from '@mui/x-data-grid-pro';
 import { gridCellSelectionStateSelector } from "./gridCellSelectionSelector.js";
 export const cellSelectionStateInitializer = (state, props) => _extends({}, state, {
   cellSelection: _extends({}, props.cellSelectionModel ?? props.initialState?.cellSelection)
@@ -354,11 +354,11 @@ export const useGridCellSelection = (apiRef, props) => {
       field
     }, cellWithVirtualFocus.current);
   });
-  useGridApiEventHandler(apiRef, 'cellClick', runIfCellSelectionIsEnabled(handleCellClick));
-  useGridApiEventHandler(apiRef, 'cellFocusIn', runIfCellSelectionIsEnabled(handleCellFocusIn));
-  useGridApiEventHandler(apiRef, 'cellKeyDown', runIfCellSelectionIsEnabled(handleCellKeyDown));
-  useGridApiEventHandler(apiRef, 'cellMouseDown', runIfCellSelectionIsEnabled(handleCellMouseDown));
-  useGridApiEventHandler(apiRef, 'cellMouseOver', runIfCellSelectionIsEnabled(handleCellMouseOver));
+  useGridEvent(apiRef, 'cellClick', runIfCellSelectionIsEnabled(handleCellClick));
+  useGridEvent(apiRef, 'cellFocusIn', runIfCellSelectionIsEnabled(handleCellFocusIn));
+  useGridEvent(apiRef, 'cellKeyDown', runIfCellSelectionIsEnabled(handleCellKeyDown));
+  useGridEvent(apiRef, 'cellMouseDown', runIfCellSelectionIsEnabled(handleCellMouseDown));
+  useGridEvent(apiRef, 'cellMouseOver', runIfCellSelectionIsEnabled(handleCellMouseOver));
   React.useEffect(() => {
     if (props.cellSelectionModel) {
       apiRef.current.setCellSelectionModel(props.cellSelectionModel);

package/esm/hooks/features/clipboard/useGridClipboardImport.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { GRID_CHECKBOX_SELECTION_FIELD, gridFocusCellSelector, gridVisibleColumnFieldsSelector, useGridApiOptionHandler, useGridApiEventHandler, gridPaginatedVisibleSortedGridRowIdsSelector, gridExpandedSortedRowIdsSelector, gridRowSelectionIdsSelector, gridRowSelectionCountSelector } from '@mui/x-data-grid';
+import { GRID_CHECKBOX_SELECTION_FIELD, gridFocusCellSelector, gridVisibleColumnFieldsSelector, useGridEventPriority, useGridEvent, gridPaginatedVisibleSortedGridRowIdsSelector, gridExpandedSortedRowIdsSelector, gridRowSelectionIdsSelector, gridRowSelectionCountSelector } from '@mui/x-data-grid';
 import { getRowIdFromRowModel, getActiveElement, useGridRegisterPipeProcessor, getPublicApiRef, isPasteShortcut, useGridLogger } from '@mui/x-data-grid/internals';
 import { warnOnce } from '@mui/x-internals/warning';
 import { GRID_DETAIL_PANEL_TOGGLE_FIELD, GRID_REORDER_COL_DEF } from '@mui/x-data-grid-pro';
@@ -328,8 +328,8 @@ export const useGridClipboardImport = (apiRef, props) => {
     }
     return initialValue;
   }, [enableClipboardPaste]);
-  useGridApiEventHandler(apiRef, 'cellKeyDown', handlePaste);
-  useGridApiOptionHandler(apiRef, 'clipboardPasteStart', props.onClipboardPasteStart);
-  useGridApiOptionHandler(apiRef, 'clipboardPasteEnd', props.onClipboardPasteEnd);
+  useGridEvent(apiRef, 'cellKeyDown', handlePaste);
+  useGridEventPriority(apiRef, 'clipboardPasteStart', props.onClipboardPasteStart);
+  useGridEventPriority(apiRef, 'clipboardPasteEnd', props.onClipboardPasteEnd);
   useGridRegisterPipeProcessor(apiRef, 'canStartEditing', checkIfCanStartEditing);
 };

package/esm/hooks/features/dataSource/useGridDataSourcePremium.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { useGridApiEventHandler as addEventHandler, useGridApiMethod, GRID_ROOT_GROUP_ID } from '@mui/x-data-grid-pro';
+import { useGridEvent as addEventHandler, useGridApiMethod, GRID_ROOT_GROUP_ID, useGridEvent } from '@mui/x-data-grid-pro';
 import { useGridDataSourceBasePro, useGridRegisterStrategyProcessor, useGridRegisterPipeProcessor } from '@mui/x-data-grid-pro/internals';
 function getKeyPremium(params) {
   return JSON.stringify([params.filterModel, params.sortModel, params.groupKeys, params.groupFields, params.start, params.end, params.aggregationModel]);
@@ -13,6 +13,7 @@ const options = {
 export const useGridDataSourcePremium = (apiRef, props) => {
   const {
     api,
+    debouncedFetchRows,
     strategyProcessor,
     events,
     setStrategyAvailability
@@ -53,6 +54,8 @@ export const useGridDataSourcePremium = (apiRef, props) => {
   Object.entries(events).forEach(([event, handler]) => {
     addEventHandler(apiRef, event, handler);
   });
+  useGridEvent(apiRef, 'rowGroupingModelChange', () => debouncedFetchRows());
+  useGridEvent(apiRef, 'aggregationModelChange', () => debouncedFetchRows());
   React.useEffect(() => {
     setStrategyAvailability();
   }, [setStrategyAvailability]);

package/esm/hooks/features/export/useGridExcelExport.js

@@ -1,7 +1,7 @@
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 const _excluded = ["worker", "exceljsPostProcess", "exceljsPreProcess", "columnsStyles", "includeHeaders", "getRowsToExport", "valueOptionsSheetName"];
 import * as React from 'react';
-import { useGridApiMethod, useGridLogger, useGridApiOptionHandler } from '@mui/x-data-grid';
+import { useGridApiMethod, useGridLogger, useGridEventPriority } from '@mui/x-data-grid';
 import { useGridRegisterPipeProcessor, exportAs, getColumnsToExport, defaultGetRowsToExport } from '@mui/x-data-grid/internals';
 import { buildExcel, getDataForValueOptionsSheet, serializeColumns, serializeRowUnsafe } from "./serializer/excelSerializer.js";
 import { GridExcelExportMenuItem } from "../../../components/index.js";
@@ -135,5 +135,5 @@ export const useGridExcelExport = (apiRef, props) => {
     }];
   }, []);
   useGridRegisterPipeProcessor(apiRef, 'exportMenu', addExportMenuButtons);
-  useGridApiOptionHandler(apiRef, 'excelExportStateChange', props.onExcelExportStateChange);
+  useGridEventPriority(apiRef, 'excelExportStateChange', props.onExcelExportStateChange);
 };

package/esm/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/esm/hooks/features/index.js

@@ -3,4 +3,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/esm/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/esm/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/esm/hooks/features/pivoting/gridPivotingSelectors.js

@@ -0,0 +1,5 @@
+import { createSelector, createRootSelector } from '@mui/x-data-grid-pro/internals';
+const gridPivotingStateSelector = createRootSelector(state => state.pivoting);
+export const gridPivotModelSelector = createSelector(gridPivotingStateSelector, pivoting => pivoting?.model);
+export const gridPivotPropsOverridesSelector = createSelector(gridPivotingStateSelector, pivoting => pivoting?.active ? pivoting.propsOverrides : undefined);
+export { gridPivotActiveSelector, gridPivotInitialColumnsSelector, gridPivotPanelOpenSelector } from '@mui/x-data-grid/internals';

package/esm/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;