@mui/x-data-grid-pro 5.17.5 → 6.0.0-alpha.1

package/legacy/utils/tree/insertDataRowInTree.js

@@ -0,0 +1,127 @@
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
+import { addGroupDefaultExpansion, getGroupRowIdFromPath, insertNodeInTree, updateGroupNodeIdAndAutoGenerated } from './utils';
+
+/**
+ * Inserts a data row in a tree.
+ * For each steps of its path:
+ * - if a node exists with the same partial path, it will register this node as the ancestor of the data row.
+ * - if not, it will create an auto-generated node and register it as ancestor of the data row.
+ */
+export var insertDataRowInTree = function insertDataRowInTree(_ref) {
+  var id = _ref.id,
+      path = _ref.path,
+      updatedGroupsManager = _ref.updatedGroupsManager,
+      tree = _ref.tree,
+      treeDepths = _ref.treeDepths,
+      onDuplicatePath = _ref.onDuplicatePath,
+      isGroupExpandedByDefault = _ref.isGroupExpandedByDefault,
+      defaultGroupingExpansionDepth = _ref.defaultGroupingExpansionDepth;
+  var parentNodeId = GRID_ROOT_GROUP_ID;
+
+  for (var depth = 0; depth < path.length; depth += 1) {
+    var _childrenFromPath, _childrenFromPath$fie;
+
+    var _path$depth = path[depth],
+        key = _path$depth.key,
+        field = _path$depth.field;
+    var fieldWithDefaultValue = field != null ? field : '__no_field__';
+    var keyWithDefaultValue = key != null ? key : '__no_key__';
+    var existingNodeIdWithPartialPath = (_childrenFromPath = tree[parentNodeId].childrenFromPath) == null ? void 0 : (_childrenFromPath$fie = _childrenFromPath[fieldWithDefaultValue]) == null ? void 0 : _childrenFromPath$fie[keyWithDefaultValue.toString()]; // When we reach the last step of the path,
+    // We need to create a node for the row passed to `insertNodeInTree`
+
+    if (depth === path.length - 1) {
+      // If no node matches the full path,
+      // We create a leaf node for the data row.
+      if (existingNodeIdWithPartialPath == null) {
+        var leafNode = {
+          type: 'leaf',
+          id: id,
+          depth: depth,
+          parent: parentNodeId,
+          groupingKey: key
+        };
+        updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNodeId, 'insertChildren');
+        insertNodeInTree({
+          node: leafNode,
+          tree: tree,
+          treeDepths: treeDepths
+        });
+      } else {
+        var existingNodeWithPartialPath = tree[existingNodeIdWithPartialPath]; // If we already have an auto-generated group matching the partial path,
+        // We replace it with the node from of data row passed to `insertNodeInTree`
+
+        if (existingNodeWithPartialPath.type === 'group' && existingNodeWithPartialPath.isAutoGenerated) {
+          updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNodeId, 'removeChildren');
+          updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNodeId, 'insertChildren');
+          updateGroupNodeIdAndAutoGenerated({
+            tree: tree,
+            treeDepths: treeDepths,
+            node: existingNodeWithPartialPath,
+            updatedNode: {
+              id: id,
+              isAutoGenerated: false
+            }
+          });
+        } else {
+          // If we have another row matching the partial path, then there is a duplicate in the dataset.
+          // We warn the user and skip the current row.
+          onDuplicatePath == null ? void 0 : onDuplicatePath(existingNodeIdWithPartialPath, id, path);
+        }
+      }
+    } // For the intermediary steps of the path,
+    // We need to make sure that there is a node matching the partial path.
+    //
+    // If no node matches the partial path,
+    // We create an auto-generated group node.
+    else if (existingNodeIdWithPartialPath == null) {
+      var nodeId = getGroupRowIdFromPath(path.slice(0, depth + 1));
+      var autoGeneratedGroupNode = {
+        type: 'group',
+        id: nodeId,
+        parent: parentNodeId,
+        depth: depth,
+        isAutoGenerated: true,
+        groupingKey: key,
+        groupingField: field,
+        children: [],
+        childrenFromPath: {}
+      };
+      updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNodeId, 'insertChildren');
+      insertNodeInTree({
+        node: addGroupDefaultExpansion({
+          node: autoGeneratedGroupNode,
+          defaultGroupingExpansionDepth: defaultGroupingExpansionDepth,
+          isGroupExpandedByDefault: isGroupExpandedByDefault
+        }),
+        tree: tree,
+        treeDepths: treeDepths
+      });
+      parentNodeId = nodeId;
+    } // For the intermediary steps of the path
+    // If a node matches the partial path, we use it as parent for the next step
+    else {
+      var currentGroupNode = tree[existingNodeIdWithPartialPath]; // If the node matching the partial path is not a group, we turn it into a group
+
+      if (currentGroupNode.type !== 'group') {
+        var groupNode = {
+          type: 'group',
+          id: currentGroupNode.id,
+          parent: currentGroupNode.parent,
+          depth: currentGroupNode.depth,
+          isAutoGenerated: false,
+          groupingKey: key,
+          groupingField: field,
+          children: [],
+          childrenFromPath: {}
+        };
+        tree[existingNodeIdWithPartialPath] = addGroupDefaultExpansion({
+          node: groupNode,
+          defaultGroupingExpansionDepth: defaultGroupingExpansionDepth,
+          isGroupExpandedByDefault: isGroupExpandedByDefault
+        });
+      }
+
+      parentNodeId = currentGroupNode.id;
+    }
+  }
+};

package/legacy/utils/tree/models.js

@@ -0,0 +1 @@
+export {};

package/legacy/utils/tree/removeDataRowFromTree.js

@@ -0,0 +1,97 @@
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
+import { getNodePathInTree, getGroupRowIdFromPath, removeNodeFromTree, updateGroupNodeIdAndAutoGenerated } from './utils';
+
+var removeNodeAndCleanParent = function removeNodeAndCleanParent(_ref) {
+  var node = _ref.node,
+      tree = _ref.tree,
+      treeDepths = _ref.treeDepths,
+      updatedGroupsManager = _ref.updatedGroupsManager;
+  removeNodeFromTree({
+    node: node,
+    tree: tree,
+    treeDepths: treeDepths
+  });
+
+  if (node.type === 'group' && node.footerId != null) {
+    removeNodeFromTree({
+      node: tree[node.footerId],
+      tree: tree,
+      treeDepths: treeDepths
+    });
+  }
+
+  var parentNode = tree[node.parent];
+  updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNode.id, 'removeChildren');
+  var shouldDeleteGroup = parentNode.id !== GRID_ROOT_GROUP_ID && parentNode.children.length === 0;
+
+  if (shouldDeleteGroup) {
+    if (parentNode.isAutoGenerated) {
+      removeNodeAndCleanParent({
+        node: node,
+        tree: tree,
+        treeDepths: treeDepths
+      });
+    } else {
+      tree[parentNode.id] = {
+        type: 'leaf',
+        id: parentNode.id,
+        depth: parentNode.depth,
+        parent: parentNode.parent,
+        groupingKey: parentNode.groupingKey
+      };
+    }
+  }
+};
+
+var replaceDataGroupWithAutoGeneratedGroup = function replaceDataGroupWithAutoGeneratedGroup(_ref2) {
+  var node = _ref2.node,
+      tree = _ref2.tree,
+      treeDepths = _ref2.treeDepths,
+      updatedGroupsManager = _ref2.updatedGroupsManager;
+  updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(node.parent, 'removeChildren');
+  updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(node.parent, 'insertChildren');
+  updateGroupNodeIdAndAutoGenerated({
+    tree: tree,
+    treeDepths: treeDepths,
+    node: node,
+    updatedNode: {
+      id: getGroupRowIdFromPath(getNodePathInTree({
+        id: node.id,
+        tree: tree
+      })),
+      isAutoGenerated: true
+    }
+  });
+};
+/**
+ * Removed a data row from the tree.
+ * If the node is a non-empty group, replace it with an auto-generated group to be able to keep displaying its children.
+ * If not, remove it and recursively clean its parent with the following rules:
+ * - An empty auto-generated should be removed from the tree
+ * - An empty non-auto-generated should be turned into a leaf
+ */
+
+
+export var removeDataRowFromTree = function removeDataRowFromTree(_ref3) {
+  var id = _ref3.id,
+      tree = _ref3.tree,
+      treeDepths = _ref3.treeDepths,
+      updatedGroupsManager = _ref3.updatedGroupsManager;
+  var node = tree[id];
+
+  if (node.type === 'group' && node.children.length > 0) {
+    replaceDataGroupWithAutoGeneratedGroup({
+      node: node,
+      tree: tree,
+      treeDepths: treeDepths,
+      updatedGroupsManager: updatedGroupsManager
+    });
+  } else {
+    removeNodeAndCleanParent({
+      node: node,
+      tree: tree,
+      treeDepths: treeDepths,
+      updatedGroupsManager: updatedGroupsManager
+    });
+  }
+};

package/legacy/utils/tree/sortRowTree.js

@@ -1,60 +1,66 @@
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
 export var sortRowTree = function sortRowTree(params) {
-  var rowIds = params.rowIds,
-      rowTree = params.rowTree,
+  var rowTree = params.rowTree,
       disableChildrenSorting = params.disableChildrenSorting,
-      sortRowList = params.sortRowList;
-  var sortedRows = []; // Group the rows by parent
+      sortRowList = params.sortRowList,
+      shouldRenderGroupBelowLeaves = params.shouldRenderGroupBelowLeaves;
+  var sortedRows = [];
+  var sortedGroupedByParentRows = new Map();
 
-  var groupedByParentRows = new Map([[null, {
-    body: [],
-    footer: null
-  }]]);
+  var sortGroup = function sortGroup(node) {
+    var shouldSortGroup = !!sortRowList && (!disableChildrenSorting || node.depth === -1);
+    var sortedRowIds;
 
-  for (var i = 0; i < rowIds.length; i += 1) {
-    var rowId = rowIds[i];
-    var node = rowTree[rowId];
-    var group = groupedByParentRows.get(node.parent);
+    if (shouldSortGroup) {
+      for (var i = 0; i < node.children.length; i += 1) {
+        var childNode = rowTree[node.children[i]];
 
-    if (!group) {
-      group = {
-        body: [],
-        footer: null
-      };
-      groupedByParentRows.set(node.parent, group);
-    }
+        if (childNode.type === 'group') {
+          sortGroup(childNode);
+        }
+      }
 
-    if (node.position === 'footer') {
-      group.footer = node;
-    } else {
-      group.body.push(node);
-    }
-  } // Apply the sorting to each list of children
+      sortedRowIds = sortRowList(node.children.map(function (childId) {
+        return rowTree[childId];
+      }));
+    } else if (shouldRenderGroupBelowLeaves) {
+      var childrenLeaves = [];
+      var childrenGroups = [];
 
+      for (var _i = 0; _i < node.children.length; _i += 1) {
+        var childId = node.children[_i];
+        var _childNode = rowTree[childId];
 
-  var sortedGroupedByParentRows = new Map();
-  groupedByParentRows.forEach(function (group, parent) {
-    if (group.body.length === 0) {
-      sortedGroupedByParentRows.set(parent, []);
+        if (_childNode.type === 'group') {
+          sortGroup(_childNode);
+          childrenGroups.push(childId);
+        } else if (_childNode.type === 'leaf') {
+          childrenLeaves.push(childId);
+        }
+      }
+
+      sortedRowIds = [].concat(childrenLeaves, childrenGroups);
     } else {
-      var groupSortedRows;
-      var depth = group.body[0].depth;
+      for (var _i2 = 0; _i2 < node.children.length; _i2 += 1) {
+        var _childNode2 = rowTree[node.children[_i2]];
 
-      if (depth > 0 && disableChildrenSorting || !sortRowList) {
-        groupSortedRows = group.body.map(function (row) {
-          return row.id;
-        });
-      } else {
-        groupSortedRows = sortRowList(group.body);
+        if (_childNode2.type === 'group') {
+          sortGroup(_childNode2);
+        }
       }
 
-      if (group.footer != null) {
-        groupSortedRows.push(group.footer.id);
-      }
+      sortedRowIds = _toConsumableArray(node.children);
+    }
 
-      sortedGroupedByParentRows.set(parent, groupSortedRows);
+    if (node.footerId != null) {
+      sortedRowIds.push(node.footerId);
     }
-  }); // Flatten the sorted lists to have children just after their parent
+
+    sortedGroupedByParentRows.set(node.id, sortedRowIds);
+  };
+
+  sortGroup(rowTree[GRID_ROOT_GROUP_ID]); // Flatten the sorted lists to have children just after their parent
 
   var insertRowListIntoSortedRows = function insertRowListIntoSortedRows(startIndex, rowList) {
     sortedRows = [].concat(_toConsumableArray(sortedRows.slice(0, startIndex)), _toConsumableArray(rowList), _toConsumableArray(sortedRows.slice(startIndex)));
@@ -71,6 +77,6 @@ export var sortRowTree = function sortRowTree(params) {
     return treeSize;
   };
 
-  insertRowListIntoSortedRows(0, sortedGroupedByParentRows.get(null));
+  insertRowListIntoSortedRows(0, sortedGroupedByParentRows.get(GRID_ROOT_GROUP_ID));
   return sortedRows;
 };

package/legacy/utils/tree/updateRowTree.js

@@ -0,0 +1,81 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
+import { isDeepEqual, getTreeNodeDescendants } from '@mui/x-data-grid/internals';
+import { insertDataRowInTree } from './insertDataRowInTree';
+import { removeDataRowFromTree } from './removeDataRowFromTree';
+import { createUpdatedGroupsManager, getNodePathInTree } from './utils';
+export var updateRowTree = function updateRowTree(params) {
+  var tree = _extends({}, params.previousTree);
+
+  var treeDepths = _extends({}, params.previousTreeDepth);
+
+  var updatedGroupsManager = createUpdatedGroupsManager();
+
+  for (var i = 0; i < params.nodes.inserted.length; i += 1) {
+    var _params$nodes$inserte = params.nodes.inserted[i],
+        id = _params$nodes$inserte.id,
+        path = _params$nodes$inserte.path;
+    insertDataRowInTree({
+      tree: tree,
+      treeDepths: treeDepths,
+      updatedGroupsManager: updatedGroupsManager,
+      id: id,
+      path: path,
+      onDuplicatePath: params.onDuplicatePath,
+      isGroupExpandedByDefault: params.isGroupExpandedByDefault,
+      defaultGroupingExpansionDepth: params.defaultGroupingExpansionDepth
+    });
+  }
+
+  for (var _i = 0; _i < params.nodes.removed.length; _i += 1) {
+    var nodeId = params.nodes.removed[_i];
+    removeDataRowFromTree({
+      tree: tree,
+      treeDepths: treeDepths,
+      updatedGroupsManager: updatedGroupsManager,
+      id: nodeId
+    });
+  }
+
+  for (var _i2 = 0; _i2 < params.nodes.modified.length; _i2 += 1) {
+    var _params$nodes$modifie = params.nodes.modified[_i2],
+        _id = _params$nodes$modifie.id,
+        _path = _params$nodes$modifie.path;
+    var pathInPreviousTree = getNodePathInTree({
+      tree: tree,
+      id: _id
+    });
+    var isInSameGroup = isDeepEqual(pathInPreviousTree, _path);
+
+    if (!isInSameGroup) {
+      removeDataRowFromTree({
+        tree: tree,
+        treeDepths: treeDepths,
+        updatedGroupsManager: updatedGroupsManager,
+        id: _id
+      });
+      insertDataRowInTree({
+        tree: tree,
+        treeDepths: treeDepths,
+        updatedGroupsManager: updatedGroupsManager,
+        id: _id,
+        path: _path,
+        onDuplicatePath: params.onDuplicatePath,
+        isGroupExpandedByDefault: params.isGroupExpandedByDefault,
+        defaultGroupingExpansionDepth: params.defaultGroupingExpansionDepth
+      });
+    } else {
+      updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(tree[_id].parent, 'modifyChildren');
+    }
+  } // TODO rows v6: Avoid walking the whole tree, we should be able to generate the new list only using slices.
+
+
+  var dataRowIds = getTreeNodeDescendants(tree, GRID_ROOT_GROUP_ID, true);
+  return {
+    tree: tree,
+    treeDepths: treeDepths,
+    groupingName: params.groupingName,
+    dataRowIds: dataRowIds,
+    updatedGroupsManager: updatedGroupsManager
+  };
+};

package/legacy/utils/tree/utils.js

@@ -0,0 +1,184 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _toPropertyKey from "@babel/runtime/helpers/esm/toPropertyKey";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
+export var getGroupRowIdFromPath = function getGroupRowIdFromPath(path) {
+  var pathStr = path.map(function (groupingCriteria) {
+    return "".concat(groupingCriteria.field, "/").concat(groupingCriteria.key);
+  }).join('-');
+  return "auto-generated-row-".concat(pathStr);
+};
+export var getNodePathInTree = function getNodePathInTree(_ref) {
+  var id = _ref.id,
+      tree = _ref.tree;
+  var path = [];
+  var node = tree[id];
+
+  while (node.id !== GRID_ROOT_GROUP_ID) {
+    path.push({
+      field: node.groupingField,
+      key: node.groupingKey
+    });
+    node = tree[node.parent];
+  }
+
+  return path;
+};
+export var addGroupDefaultExpansion = function addGroupDefaultExpansion(_ref2) {
+  var node = _ref2.node,
+      isGroupExpandedByDefault = _ref2.isGroupExpandedByDefault,
+      defaultGroupingExpansionDepth = _ref2.defaultGroupingExpansionDepth;
+  var childrenExpanded;
+
+  if (node.id === GRID_ROOT_GROUP_ID) {
+    childrenExpanded = true;
+  } else if (isGroupExpandedByDefault) {
+    childrenExpanded = isGroupExpandedByDefault(node);
+  } else {
+    childrenExpanded = defaultGroupingExpansionDepth === -1 || defaultGroupingExpansionDepth > node.depth;
+  }
+
+  return _extends({}, node, {
+    childrenExpanded: childrenExpanded
+  });
+};
+/**
+ * Insert a node in the tree
+ */
+
+export var insertNodeInTree = function insertNodeInTree(_ref3) {
+  var _treeDepths$node$dept;
+
+  var node = _ref3.node,
+      tree = _ref3.tree,
+      treeDepths = _ref3.treeDepths;
+  // 1. Insert node in the tree.
+  tree[node.id] = node; // 2. Increment the `treeDepths` object for the node's depth.
+
+  treeDepths[node.depth] = ((_treeDepths$node$dept = treeDepths[node.depth]) != null ? _treeDepths$node$dept : 0) + 1; // 3. Register the new node in its parent.
+
+  var parentNode = tree[node.parent];
+
+  if (node.type === 'footer') {
+    // For footers,
+    // Register the node from its parent `footerId` property.
+    tree[node.parent] = _extends({}, parentNode, {
+      footerId: node.id
+    });
+  } else if (node.type === 'group' || node.type === 'leaf') {
+    var _groupingField, _groupingKey, _parentNode$childrenF;
+
+    // For groups and leaves,
+    // Register the node from its parents `children` and `childrenFromPath` properties.
+    var groupingField = (_groupingField = node.groupingField) != null ? _groupingField : '__no_field__';
+    var groupingKey = (_groupingKey = node.groupingKey) != null ? _groupingKey : '__no_key__';
+    tree[node.parent] = _extends({}, parentNode, {
+      childrenFromPath: _extends({}, parentNode.childrenFromPath, _defineProperty({}, groupingField, _extends({}, (_parentNode$childrenF = parentNode.childrenFromPath) == null ? void 0 : _parentNode$childrenF[groupingField], _defineProperty({}, groupingKey.toString(), node.id)))),
+      children: [].concat(_toConsumableArray(parentNode.children), [node.id])
+    });
+  }
+};
+/**
+ * Removes a node from the tree
+ */
+
+export var removeNodeFromTree = function removeNodeFromTree(_ref4) {
+  var node = _ref4.node,
+      tree = _ref4.tree,
+      treeDepths = _ref4.treeDepths;
+  // 1. Remove node from the tree.
+  delete tree[node.id]; // 2. Decrement the `treeDepths` object for the node's depth.
+
+  var nodeDepth = node.depth;
+  var currentNodeCount = treeDepths[nodeDepth];
+
+  if (currentNodeCount === 1) {
+    delete treeDepths[nodeDepth];
+  } else {
+    treeDepths[nodeDepth] = currentNodeCount - 1;
+  } // 3. Unregister the new node in its parent.
+
+
+  var parentNode = tree[node.parent]; // For footers,
+  // Unregister the node from its parent `footerId` property.
+
+  if (node.type === 'footer') {
+    tree[parentNode.id] = _extends({}, parentNode, {
+      footerId: null
+    });
+  } // For groups and leaves,
+  // Unregister the node from its parents `children` and `childrenFromPath` properties.
+  else {
+    var _groupingField2, _groupingKey2, _parentNode$childrenF2, _parentNode$childrenF3;
+
+    var groupingField = (_groupingField2 = node.groupingField) != null ? _groupingField2 : '__no_field__';
+    var groupingKey = (_groupingKey2 = node.groupingKey) != null ? _groupingKey2 : '__no_key__';
+
+    var _ref5 = (_parentNode$childrenF2 = (_parentNode$childrenF3 = parentNode.childrenFromPath) == null ? void 0 : _parentNode$childrenF3[groupingField]) != null ? _parentNode$childrenF2 : {},
+        _groupingKey$toString = groupingKey.toString(),
+        childrenToRemove = _ref5[_groupingKey$toString],
+        newChildrenFromPathWithField = _objectWithoutProperties(_ref5, [_groupingKey$toString].map(_toPropertyKey)); // TODO rows v6: Can we avoid this linear complexity ?
+
+
+    var children = parentNode.children.filter(function (childId) {
+      return childId !== node.id;
+    });
+
+    var childrenFromPath = _extends({}, parentNode.childrenFromPath);
+
+    if (Object.keys(newChildrenFromPathWithField).length === 0) {
+      delete childrenFromPath[groupingField];
+    } else {
+      childrenFromPath[groupingField] = newChildrenFromPathWithField;
+    }
+
+    tree[parentNode.id] = _extends({}, parentNode, {
+      children: children,
+      childrenFromPath: childrenFromPath
+    });
+  }
+};
+/**
+ * Updates the `id` and `isAutoGenerated` properties of a group node.
+ */
+
+export var updateGroupNodeIdAndAutoGenerated = function updateGroupNodeIdAndAutoGenerated(_ref6) {
+  var node = _ref6.node,
+      updatedNode = _ref6.updatedNode,
+      tree = _ref6.tree,
+      treeDepths = _ref6.treeDepths;
+  // 1. Set the new parent for all children from the old group
+  node.children.forEach(function (childId) {
+    tree[childId] = _extends({}, tree[childId], {
+      parent: updatedNode.id
+    });
+  }); // 2. Remove the old group from the tree
+
+  removeNodeFromTree({
+    node: node,
+    tree: tree,
+    treeDepths: treeDepths
+  }); // 3. Add the new group in the tree
+
+  var groupNode = _extends({}, node, updatedNode);
+
+  insertNodeInTree({
+    node: groupNode,
+    tree: tree,
+    treeDepths: treeDepths
+  });
+};
+export var createUpdatedGroupsManager = function createUpdatedGroupsManager() {
+  return {
+    value: {},
+    addAction: function addAction(groupId, action) {
+      if (!this.value[groupId]) {
+        this.value[groupId] = {};
+      }
+
+      this.value[groupId][action] = true;
+    }
+  };
+};

package/models/dataGridProProps.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { GridRowTreeNodeConfig, GridEventListener, GridCallbackDetails, GridRowParams, GridRowId, GridValidRowModel, GridFeatureMode } from '@mui/x-data-grid';
+import { GridEventListener, GridCallbackDetails, GridRowParams, GridRowId, GridValidRowModel, GridGroupNode, GridFeatureMode } from '@mui/x-data-grid';
 import { GridExperimentalFeatures, DataGridPropsWithoutDefaultValue, DataGridPropsWithDefaultValues, DataGridPropsWithComplexDefaultValueAfterProcessing, DataGridPropsWithComplexDefaultValueBeforeProcessing } from '@mui/x-data-grid/internals';
 import type { GridPinnedColumns } from '../hooks/features/columnPinning';
 import type { GridPinnedRowsProp } from '../hooks/features/rowPinning';
@@ -52,10 +52,10 @@ export interface DataGridProPropsWithDefaultValue extends DataGridPropsWithDefau
     /**
      * Determines if a group should be expanded after its creation.
      * This prop takes priority over the `defaultGroupingExpansionDepth` prop.
-     * @param {GridRowTreeNodeConfig} node The node of the group to test.
+     * @param {GridGroupNode} node The node of the group to test.
      * @returns {boolean} A boolean indicating if the group is expanded.
      */
-    isGroupExpandedByDefault?: (node: GridRowTreeNodeConfig) => boolean;
+    isGroupExpandedByDefault?: (node: GridGroupNode) => boolean;
     /**
      * If `true`, the column pinning is disabled.
      * @default false

package/modern/DataGridPro/DataGridPro.js

@@ -437,7 +437,7 @@ DataGridProRaw.propTypes = {
   /**
    * Determines if a group should be expanded after its creation.
    * This prop takes priority over the `defaultGroupingExpansionDepth` prop.
-   * @param {GridRowTreeNodeConfig} node The node of the group to test.
+   * @param {GridGroupNode} node The node of the group to test.
    * @returns {boolean} A boolean indicating if the group is expanded.
    */
   isGroupExpandedByDefault: PropTypes.func,
@@ -615,16 +615,6 @@ DataGridProRaw.propTypes = {
    */
   onColumnResize: PropTypes.func,
 
-  /**
-   * Callback fired when a column visibility changes.
-   * Only works when no `columnVisibilityModel` is provided and if we change the visibility of a single column at a time.
-   * @param {GridColumnVisibilityChangeParams} params With all properties from [[GridColumnVisibilityChangeParams]].
-   * @param {MuiEvent<{}>} event The event object.
-   * @param {GridCallbackDetails} details Additional details for this callback.
-   * @deprecated Use `onColumnVisibilityModelChange` instead.
-   */
-  onColumnVisibilityChange: PropTypes.func,
-
   /**
    * Callback fired when the column visibility model changes.
    * @param {GridColumnVisibilityModel} model The new model.
@@ -876,8 +866,8 @@ DataGridProRaw.propTypes = {
    * Rows data to pin on top or bottom.
    */
   pinnedRows: PropTypes.shape({
-    bottom: PropTypes.array,
-    top: PropTypes.array
+    bottom: PropTypes.arrayOf(PropTypes.object),
+    top: PropTypes.arrayOf(PropTypes.object)
   }),
 
   /**
@@ -922,7 +912,7 @@ DataGridProRaw.propTypes = {
   /**
    * Set of rows of type [[GridRowsProp]].
    */
-  rows: PropTypes.array.isRequired,
+  rows: PropTypes.arrayOf(PropTypes.object).isRequired,
 
   /**
    * Loading rows can be processed on the server or client-side.