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

package/esm/typeOverloads/modules.d.ts

@@ -1,10 +1,11 @@
 import { GridExportDisplayOptions, GridValidRowModel } from '@mui/x-data-grid-pro';
 import type { GridControlledStateEventLookupPro, GridApiCachesPro, GridEventLookupPro } from '@mui/x-data-grid-pro/typeOverloads';
 import type { GridGroupingValueGetter, GridPastedValueParser } from '../models';
-import type { GridRowGroupingModel, GridAggregationModel, GridAggregationCellMeta, GridAggregationHeaderMeta, GridCellSelectionModel } from '../hooks';
+import type { GridRowGroupingModel, GridAggregationModel, GridAggregationCellMeta, GridAggregationHeaderMeta, GridCellSelectionModel, Conversation } from '../hooks';
 import { GridRowGroupingInternalCache } from "../hooks/features/rowGrouping/gridRowGroupingInterfaces.js";
 import { GridAggregationInternalCache } from "../hooks/features/aggregation/gridAggregationInterfaces.js";
 import type { GridExcelExportOptions } from '../hooks/features/export/gridExcelExportInterface';
+import type { GridPivotModel } from '../hooks/features/pivoting/gridPivotingInterfaces';
 export interface GridControlledStateEventLookupPremium {
   /**
    * Fired when the aggregation model changes.
@@ -30,6 +31,30 @@ export interface GridControlledStateEventLookupPremium {
   excelExportStateChange: {
     params: 'pending' | 'finished';
   };
+  /**
+   * Fired when the pivot model changes.
+   */
+  pivotModelChange: {
+    params: GridPivotModel;
+  };
+  pivotModeChange: {
+    params: boolean;
+  };
+  pivotPanelOpenChange: {
+    params: boolean;
+  };
+  /**
+   * Fired when the AI Assistant conversation state changes.
+   */
+  aiAssistantConversationsChange: {
+    params: Conversation[];
+  };
+  /**
+   * Fired when the AI Assistant active conversation index changes.
+   */
+  aiAssistantActiveConversationIndexChange: {
+    params: number;
+  };
 }
 interface GridEventLookupPremium extends GridEventLookupPro {
   /**
@@ -58,6 +83,7 @@ export interface GridColDefPremium<R extends GridValidRowModel = any, V = any, F
   availableAggregationFunctions?: string[];
   /**
    * Function that transforms a complex cell value into a key that be used for grouping the rows.
+   * Not supported with the server-side row grouping. Use `dataSource.getGroupKey()` instead.
    * @returns {GridKeyValue | null | undefined} The cell key.
    */
   groupingValueGetter?: GridGroupingValueGetter<R>;
@@ -66,6 +92,11 @@ export interface GridColDefPremium<R extends GridValidRowModel = any, V = any, F
    * @returns {V} The converted value.
    */
   pastedValueParser?: GridPastedValueParser<R, V, F>;
+  /**
+   * If `false`, the column will not be available for pivoting in the pivot panel.
+   * @default true
+   */
+  pivotable?: boolean;
 }
 export interface GridRenderCellParamsPremium<R extends GridValidRowModel = any, V = any, F = V> {
   aggregation?: GridAggregationCellMeta;

package/esm/utils/speechRecognition.d.ts

@@ -0,0 +1,2 @@
+export declare const BrowserSpeechRecognition: any;
+export declare const IS_SPEECH_RECOGNITION_SUPPORTED: boolean;

package/esm/utils/speechRecognition.js

@@ -0,0 +1,2 @@
+export const BrowserSpeechRecognition = globalThis.SpeechRecognition || globalThis.webkitSpeechRecognition;
+export const IS_SPEECH_RECOGNITION_SUPPORTED = !!BrowserSpeechRecognition;

package/hooks/features/aggregation/gridAggregationFunctions.js

@@ -36,6 +36,9 @@ const avgAgg = {
         sum += value;
       }
     }
+    if (sum === 0) {
+      return null;
+    }
     return sum / valuesCount;
   },
   columnTypes: ['number']
@@ -47,13 +50,18 @@ const minAgg = {
     if (values.length === 0) {
       return null;
     }
+    let hasValidValue = false;
     let min = +Infinity;
     for (let i = 0; i < values.length; i += 1) {
       const value = values[i];
       if (value != null && value < min) {
         min = value;
+        hasValidValue = true;
       }
     }
+    if (!hasValidValue) {
+      return null;
+    }
     return min;
   },
   columnTypes: ['number', 'date', 'dateTime']
@@ -65,13 +73,18 @@ const maxAgg = {
     if (values.length === 0) {
       return null;
     }
+    let hasValidValue = false;
     let max = -Infinity;
     for (let i = 0; i < values.length; i += 1) {
       const value = values[i];
       if (value != null && value > max) {
         max = value;
+        hasValidValue = true;
       }
     }
+    if (!hasValidValue) {
+      return null;
+    }
     return max;
   },
   columnTypes: ['number', 'date', 'dateTime']

package/hooks/features/aggregation/gridAggregationSelectors.d.ts

@@ -1,4 +1,6 @@
+import { GridRowId } from '@mui/x-data-grid';
 import { GridStatePremium } from "../../../models/gridStatePremium.js";
+import { GridAggregationPosition } from "./gridAggregationInterfaces.js";
 export declare const gridAggregationStateSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, unknown, import("./gridAggregationInterfaces").GridAggregationState>;
 /**
  * Get the aggregation model, containing the aggregation function of each column.
@@ -10,4 +12,11 @@ export declare const gridAggregationModelSelector: import("@mui/x-data-grid").Ou
  * Get the aggregation results as a lookup.
  * @category Aggregation
  */
-export declare const gridAggregationLookupSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridAggregationInterfaces").GridAggregationState, import("./gridAggregationInterfaces").GridAggregationLookup>;
+export declare const gridAggregationLookupSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridAggregationInterfaces").GridAggregationState, import("./gridAggregationInterfaces").GridAggregationLookup>;
+export declare const gridCellAggregationResultSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, {
+  id: GridRowId;
+  field: string;
+}, {
+  position: GridAggregationPosition;
+  value: any;
+} | null>;

package/hooks/features/aggregation/gridAggregationSelectors.js

@@ -3,8 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.gridAggregationStateSelector = exports.gridAggregationModelSelector = exports.gridAggregationLookupSelector = void 0;
+exports.gridCellAggregationResultSelector = exports.gridAggregationStateSelector = exports.gridAggregationModelSelector = exports.gridAggregationLookupSelector = void 0;
 var _internals = require("@mui/x-data-grid-pro/internals");
+var _xDataGrid = require("@mui/x-data-grid");
 const gridAggregationStateSelector = exports.gridAggregationStateSelector = (0, _internals.createRootSelector)(state => state.aggregation);
 
 /**
@@ -18,4 +19,30 @@ const gridAggregationModelSelector = exports.gridAggregationModelSelector = (0,
  * Get the aggregation results as a lookup.
  * @category Aggregation
  */
-const gridAggregationLookupSelector = exports.gridAggregationLookupSelector = (0, _internals.createSelector)(gridAggregationStateSelector, aggregationState => aggregationState.lookup);
+const gridAggregationLookupSelector = exports.gridAggregationLookupSelector = (0, _internals.createSelector)(gridAggregationStateSelector, aggregationState => aggregationState.lookup);
+const gridCellAggregationResultSelector = exports.gridCellAggregationResultSelector = (0, _internals.createSelector)(_xDataGrid.gridRowTreeSelector, gridAggregationLookupSelector, (rowTree, aggregationLookup, {
+  id,
+  field
+}) => {
+  let cellAggregationPosition = null;
+  const rowNode = rowTree[id];
+  if (!rowNode) {
+    return null;
+  }
+  if (rowNode.type === 'group') {
+    cellAggregationPosition = 'inline';
+  } else if (id.toString().startsWith('auto-generated-group-footer-')) {
+    cellAggregationPosition = 'footer';
+  }
+  if (cellAggregationPosition == null) {
+    return null;
+  }
+
+  // TODO: Add custom root id
+  const groupId = cellAggregationPosition === 'inline' ? id : rowNode.parent ?? '';
+  const aggregationResult = aggregationLookup?.[groupId]?.[field];
+  if (!aggregationResult || aggregationResult.position !== cellAggregationPosition) {
+    return null;
+  }
+  return aggregationResult;
+});

package/hooks/features/aggregation/gridAggregationUtils.d.ts

@@ -3,7 +3,7 @@ import { GridColDef, GridRowId } from '@mui/x-data-grid-pro';
 import { GridColumnRawLookup, GridHydrateRowsValue } from '@mui/x-data-grid-pro/internals';
 import { GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationModel, GridAggregationRule, GridAggregationRules } from "./gridAggregationInterfaces.js";
 import { GridStatePremium } from "../../../models/gridStatePremium.js";
-import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import type { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
 import { GridApiPremium, GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
 export declare const GRID_AGGREGATION_ROOT_FOOTER_ROW_ID = "auto-generated-group-footer-root";
 export declare const getAggregationFooterRowIdFromGroupId: (groupId: GridRowId | null) => string;

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

@@ -1,4 +1,4 @@
 export type { GridAggregationState, GridAggregationInitialState, GridAggregationInternalCache, GridAggregationApi, GridAggregationGetCellValueParams, GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationParams, GridAggregationModel, GridAggregationLookup, GridAggregationPosition, GridAggregationCellMeta, GridAggregationHeaderMeta, GridAggregationRule, GridAggregationRules } from './gridAggregationInterfaces';
-export * from "./gridAggregationSelectors.js";
+export { gridAggregationStateSelector, gridAggregationLookupSelector, gridAggregationModelSelector } from "./gridAggregationSelectors.js";
 export * from "./gridAggregationFunctions.js";
 export { GRID_AGGREGATION_ROOT_FOOTER_ROW_ID, getAggregationFooterRowIdFromGroupId } from "./gridAggregationUtils.js";

package/hooks/features/aggregation/index.js

@@ -4,6 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
+  gridAggregationStateSelector: true,
+  gridAggregationLookupSelector: true,
+  gridAggregationModelSelector: true,
   GRID_AGGREGATION_ROOT_FOOTER_ROW_ID: true,
   getAggregationFooterRowIdFromGroupId: true
 };
@@ -19,18 +22,25 @@ Object.defineProperty(exports, "getAggregationFooterRowIdFromGroupId", {
     return _gridAggregationUtils.getAggregationFooterRowIdFromGroupId;
   }
 });
-var _gridAggregationSelectors = require("./gridAggregationSelectors");
-Object.keys(_gridAggregationSelectors).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _gridAggregationSelectors[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _gridAggregationSelectors[key];
-    }
-  });
+Object.defineProperty(exports, "gridAggregationLookupSelector", {
+  enumerable: true,
+  get: function () {
+    return _gridAggregationSelectors.gridAggregationLookupSelector;
+  }
+});
+Object.defineProperty(exports, "gridAggregationModelSelector", {
+  enumerable: true,
+  get: function () {
+    return _gridAggregationSelectors.gridAggregationModelSelector;
+  }
 });
+Object.defineProperty(exports, "gridAggregationStateSelector", {
+  enumerable: true,
+  get: function () {
+    return _gridAggregationSelectors.gridAggregationStateSelector;
+  }
+});
+var _gridAggregationSelectors = require("./gridAggregationSelectors");
 var _gridAggregationFunctions = require("./gridAggregationFunctions");
 Object.keys(_gridAggregationFunctions).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/hooks/features/aggregation/useGridAggregation.js

@@ -83,13 +83,9 @@ 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 (!(0, _gridAggregationUtils.areAggregationRulesEqual)(rulesOnLastRowHydration, aggregationRules)) {
-      if (props.dataSource) {
-        apiRef.current.dataSource.fetchRows();
-      } else {
-        apiRef.current.requestPipeProcessorsApplication('hydrateRows');
-        applyAggregation();
-      }
+    if (!props.dataSource && !(0, _gridAggregationUtils.areAggregationRulesEqual)(rulesOnLastRowHydration, aggregationRules)) {
+      apiRef.current.requestPipeProcessorsApplication('hydrateRows');
+      applyAggregation();
     }
 
     // Re-apply the column hydration to wrap / unwrap the aggregated columns
@@ -97,9 +93,9 @@ const useGridAggregation = (apiRef, props) => {
       apiRef.current.requestPipeProcessorsApplication('hydrateColumns');
     }
   }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation, props.dataSource]);
-  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'aggregationModelChange', checkAggregationRulesDiff);
-  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'columnsChange', checkAggregationRulesDiff);
-  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'filteredRowsSet', applyAggregation);
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'aggregationModelChange', checkAggregationRulesDiff);
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'columnsChange', checkAggregationRulesDiff);
+  (0, _xDataGridPro.useGridEvent)(apiRef, 'filteredRowsSet', applyAggregation);
 
   /**
    * EFFECTS

package/hooks/features/aggregation/useGridAggregationPreProcessors.js

@@ -24,16 +24,10 @@ const useGridAggregationPreProcessors = (apiRef, props) => {
       const haveAggregationColumnValue = !!rulesOnLastColumnHydration.current[field];
       let column = columnsState.lookup[field];
       if (haveAggregationColumnValue) {
-        column = (0, _wrapColumnWithAggregation.unwrapColumnFromAggregation)({
-          column
-        });
+        column = (0, _wrapColumnWithAggregation.unwrapColumnFromAggregation)(column);
       }
       if (shouldHaveAggregationValue) {
-        column = (0, _wrapColumnWithAggregation.wrapColumnWithAggregationValue)({
-          column,
-          aggregationRule: aggregationRules[field],
-          apiRef
-        });
+        column = (0, _wrapColumnWithAggregation.wrapColumnWithAggregationValue)(column, aggregationRules[field], apiRef);
       }
       columnsState.lookup[field] = column;
     });

package/hooks/features/aggregation/wrapColumnWithAggregation.d.ts

@@ -4,34 +4,14 @@ import { GridColDef, GridFilterOperator } from '@mui/x-data-grid-pro';
 import { type GridBaseColDef } from '@mui/x-data-grid-pro/internals';
 import { GridApiPremium } from "../../../models/gridApiPremium.js";
 import type { GridAggregationRule } from './gridAggregationInterfaces';
-type WrappableColumnProperty = 'valueGetter' | 'valueFormatter' | 'renderCell' | 'renderHeader' | 'filterOperators';
-interface GridColDefWithAggregationWrappers extends GridBaseColDef {
-  aggregationWrappedProperties: {
-    name: WrappableColumnProperty;
-    originalValue: GridBaseColDef[WrappableColumnProperty];
-    wrappedValue: GridBaseColDef[WrappableColumnProperty];
-  }[];
-}
 /**
  * Add a wrapper around each wrappable property of the column to customize the behavior of the aggregation cells.
  */
-export declare const wrapColumnWithAggregationValue: ({
-  column,
-  apiRef,
-  aggregationRule
-}: {
-  column: GridBaseColDef;
-  apiRef: RefObject<GridApiPremium>;
-  aggregationRule: GridAggregationRule;
-}) => GridBaseColDef;
+export declare const wrapColumnWithAggregationValue: (column: GridBaseColDef, aggregationRule: GridAggregationRule, apiRef: RefObject<GridApiPremium>) => GridBaseColDef;
 /**
  * Remove the aggregation wrappers around the wrappable properties of the column.
  */
-export declare const unwrapColumnFromAggregation: ({
-  column
-}: {
-  column: GridColDef | GridColDefWithAggregationWrappers;
-}) => GridBaseColDef<any, any, any> | {
+export declare const unwrapColumnFromAggregation: (column: GridColDef) => GridBaseColDef<any, any, any> | {
   field: string;
   headerName?: string;
   description?: string;
@@ -71,11 +51,11 @@ export declare const unwrapColumnFromAggregation: ({
   disableReorder?: boolean;
   disableExport?: boolean;
   colSpan?: number | import("@mui/x-data-grid").GridColSpanFn<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
-  unstable_examples?: any[] | undefined;
+  examples?: any[] | undefined;
   renderHeaderFilter?: (params: import("@mui/x-data-grid-pro").GridRenderHeaderFilterProps) => React.ReactNode;
   aggregable?: boolean;
   availableAggregationFunctions?: string[];
   groupingValueGetter?: import("../../..").GridGroupingValueGetter<import("@mui/x-data-grid").GridValidRowModel> | undefined;
   pastedValueParser?: import("../../..").GridPastedValueParser<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
-};
-export {};
+  pivotable?: boolean;
+};

package/hooks/features/aggregation/wrapColumnWithAggregation.js

@@ -13,6 +13,7 @@ var _xDataGridPro = require("@mui/x-data-grid-pro");
 var _gridAggregationSelectors = require("./gridAggregationSelectors");
 var _GridFooterCell = require("../../../components/GridFooterCell");
 var _GridAggregationHeader = require("../../../components/GridAggregationHeader");
+var _gridPivotingSelectors = require("../pivoting/gridPivotingSelectors");
 var _jsxRuntime = require("react/jsx-runtime");
 const _excluded = ["aggregationWrappedProperties"];
 const getAggregationValueWrappedValueGetter = ({
@@ -60,8 +61,10 @@ const getAggregationValueWrappedValueFormatter = ({
 const getAggregationValueWrappedRenderCell = ({
   value: renderCell,
   aggregationRule,
-  getCellAggregationResult
+  getCellAggregationResult,
+  apiRef
 }) => {
+  const pivotActive = (0, _gridPivotingSelectors.gridPivotActiveSelector)(apiRef);
   const wrappedRenderCell = params => {
     const cellAggregationResult = getCellAggregationResult(params.id, params.field);
     if (cellAggregationResult != null) {
@@ -69,8 +72,14 @@ const getAggregationValueWrappedRenderCell = ({
         if (cellAggregationResult.position === 'footer') {
           return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridFooterCell.GridFooterCell, (0, _extends2.default)({}, params));
         }
+        if (pivotActive && cellAggregationResult.value === 0) {
+          return null;
+        }
         return params.formattedValue;
       }
+      if (pivotActive && cellAggregationResult.value === 0) {
+        return null;
+      }
       const aggregationMeta = {
         hasCellUnit: aggregationRule.aggregationFunction.hasCellUnit ?? true,
         aggregationFunctionName: aggregationRule.aggregationFunctionName
@@ -122,6 +131,10 @@ const getWrappedRenderHeader = ({
   aggregationRule
 }) => {
   const wrappedRenderHeader = params => {
+    // TODO: investigate why colDef is undefined
+    if (!params.colDef) {
+      return null;
+    }
     return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridAggregationHeader.GridAggregationHeader, (0, _extends2.default)({}, params, {
       aggregation: {
         aggregationRule
@@ -135,14 +148,13 @@ const getWrappedRenderHeader = ({
 /**
  * Add a wrapper around each wrappable property of the column to customize the behavior of the aggregation cells.
  */
-const wrapColumnWithAggregationValue = ({
-  column,
-  apiRef,
-  aggregationRule
-}) => {
+const wrapColumnWithAggregationValue = (column, aggregationRule, apiRef) => {
   const getCellAggregationResult = (id, field) => {
     let cellAggregationPosition = null;
     const rowNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, id);
+    if (!rowNode) {
+      return null;
+    }
     if (rowNode.type === 'group') {
       cellAggregationPosition = 'inline';
     } else if (id.toString().startsWith('auto-generated-group-footer-')) {
@@ -193,15 +205,16 @@ const wrapColumnWithAggregationValue = ({
   }
   return wrappedColumn;
 };
+exports.wrapColumnWithAggregationValue = wrapColumnWithAggregationValue;
+const isColumnWrappedWithAggregation = column => {
+  return typeof column.aggregationWrappedProperties !== 'undefined';
+};
 
 /**
  * Remove the aggregation wrappers around the wrappable properties of the column.
  */
-exports.wrapColumnWithAggregationValue = wrapColumnWithAggregationValue;
-const unwrapColumnFromAggregation = ({
-  column
-}) => {
-  if (!column.aggregationWrappedProperties) {
+const unwrapColumnFromAggregation = column => {
+  if (!isColumnWrappedWithAggregation(column)) {
     return column;
   }
   const _ref = column,

package/hooks/features/aiAssistant/api.d.ts

@@ -0,0 +1,12 @@
+import { PromptResponse } from "./gridAiAssistantInterfaces.js";
+/**
+ * Prompt resolver for the <DataGridPremium /> component.
+ * @param {string} url The URL to send the request to.
+ * @param {string} query The query to be processed.
+ * @param {string} context The prompt context containing necessary information about the current columns definition.
+ * Either use the `context` parameter of the `onPrompt` callback or the return value of the `unstable_getPromptContext()` API method.
+ * @param {string} conversationId The id of the conversation the prompt is part of. If not passed, prompt response will return a new conversation id that can be used to continue the newly started conversation.
+ * @param {string} additionalContext Optional, additional context to make the processing results more accurate.
+ * @returns {Promise<PromptResponse>} The grid state updates to be applied.
+ */
+export declare function gridDefaultPromptResolver(url: string, query: string, context: string, conversationId?: string, additionalContext?: string): Promise<PromptResponse>;

package/hooks/features/aiAssistant/api.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gridDefaultPromptResolver = gridDefaultPromptResolver;
+/**
+ * Prompt resolver for the <DataGridPremium /> component.
+ * @param {string} url The URL to send the request to.
+ * @param {string} query The query to be processed.
+ * @param {string} context The prompt context containing necessary information about the current columns definition.
+ * Either use the `context` parameter of the `onPrompt` callback or the return value of the `unstable_getPromptContext()` API method.
+ * @param {string} conversationId The id of the conversation the prompt is part of. If not passed, prompt response will return a new conversation id that can be used to continue the newly started conversation.
+ * @param {string} additionalContext Optional, additional context to make the processing results more accurate.
+ * @returns {Promise<PromptResponse>} The grid state updates to be applied.
+ */
+function gridDefaultPromptResolver(url, query, context, conversationId, additionalContext = '') {
+  return fetch(url, {
+    mode: 'cors',
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    credentials: 'include',
+    body: JSON.stringify({
+      context,
+      query,
+      additionalContext,
+      conversationId
+    })
+  }).then(result => result.json()).then(result => {
+    if (result.ok === false) {
+      return Promise.reject(new Error(result.message));
+    }
+    return result.data;
+  });
+}

package/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/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/hooks/features/aiAssistant/gridAiAssistantSelectors.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gridAiAssistantConversationsSelector = exports.gridAiAssistantActiveConversationSelector = exports.gridAiAssistantActiveConversationIndexSelector = void 0;
+var _internals = require("@mui/x-data-grid-pro/internals");
+const gridAiAssistantStateSelector = (0, _internals.createRootSelector)(state => state.aiAssistant);
+const gridAiAssistantActiveConversationIndexSelector = exports.gridAiAssistantActiveConversationIndexSelector = (0, _internals.createSelector)(gridAiAssistantStateSelector, aiAssistant => aiAssistant?.activeConversationIndex);
+const gridAiAssistantConversationsSelector = exports.gridAiAssistantConversationsSelector = (0, _internals.createSelector)(gridAiAssistantStateSelector, aiAssistant => aiAssistant?.conversations);
+const gridAiAssistantActiveConversationSelector = exports.gridAiAssistantActiveConversationSelector = (0, _internals.createSelectorMemoized)(gridAiAssistantConversationsSelector, gridAiAssistantActiveConversationIndexSelector, (conversations, index) => conversations[index]);

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