@mui/x-data-grid 6.0.0-alpha.0 → 6.0.0-alpha.2

package/legacy/hooks/features/rows/useGridRows.js

@@ -1,16 +1,16 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 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 * as React from 'react';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { useGridLogger } from '../../utils/useGridLogger';
-import { gridRowCountSelector, gridRowsLookupSelector, gridRowTreeSelector, gridRowIdsSelector, gridRowGroupingNameSelector, gridRowsIdToIdLookupSelector } from './gridRowsSelector';
+import { gridRowCountSelector, gridRowsLookupSelector, gridRowTreeSelector, gridRowGroupingNameSelector, gridRowTreeDepthsSelector, gridDataRowIdsSelector, gridRowsDataRowIdToIdLookupSelector, gridRowMaximumTreeDepthSelector } from './gridRowsSelector';
 import { GridSignature, useGridApiEventHandler } from '../../utils/useGridApiEventHandler';
 import { useGridVisibleRows } from '../../utils/useGridVisibleRows';
 import { gridSortedRowIdsSelector } from '../sorting/gridSortingSelector';
 import { gridFilteredRowsLookupSelector } from '../filter/gridFilterSelector';
-import { getTreeNodeDescendants, createRowsInternalCache, getRowsStateFromCache, getRowIdFromRowModel } from './gridRowsUtils';
+import { getTreeNodeDescendants, createRowsInternalCache, getRowsStateFromCache, isAutoGeneratedRow, GRID_ROOT_GROUP_ID, updateCacheWithNewRows, getTopLevelRowCount, getRowIdFromRowModel } from './gridRowsUtils';
 import { useGridRegisterPipeApplier } from '../../core/pipeProcessing';
 export var rowsStateInitializer = function rowsStateInitializer(state, props, apiRef) {
   apiRef.current.unstable_caches.rows = createRowsInternalCache({
@@ -21,9 +21,10 @@ export var rowsStateInitializer = function rowsStateInitializer(state, props, ap
   return _extends({}, state, {
     rows: getRowsStateFromCache({
       apiRef: apiRef,
-      previousTree: null,
       rowCountProp: props.rowCount,
-      loadingProp: props.loading
+      loadingProp: props.loading,
+      previousTree: null,
+      previousTreeDepths: null
     })
   });
 };
@@ -41,18 +42,32 @@ export var useGridRows = function useGridRows(apiRef, props) {
   var lastUpdateMs = React.useRef(Date.now());
   var timeout = React.useRef(null);
   var getRow = React.useCallback(function (id) {
-    var _ref;
+    var model = gridRowsLookupSelector(apiRef)[id];
+
+    if (model) {
+      return model;
+    }
+
+    var node = apiRef.current.getRowNode(id);
+
+    if (node && isAutoGeneratedRow(node)) {
+      // TODO rows v6: Is it the best approach ?
+      return {};
+    }
 
-    return (_ref = gridRowsLookupSelector(apiRef)[id]) != null ? _ref : null;
+    return null;
   }, [apiRef]);
   var lookup = React.useMemo(function () {
-    return currentPage.rows.reduce(function (acc, _ref2, index) {
-      var id = _ref2.id;
+    return currentPage.rows.reduce(function (acc, _ref, index) {
+      var id = _ref.id;
       acc[id] = index;
       return acc;
     }, {});
   }, [currentPage.rows]);
-  var throttledRowsChange = React.useCallback(function (newCache, throttle) {
+  var throttledRowsChange = React.useCallback(function (_ref2) {
+    var cache = _ref2.cache,
+        throttle = _ref2.throttle;
+
     var run = function run() {
       timeout.current = null;
       lastUpdateMs.current = Date.now();
@@ -60,9 +75,10 @@ export var useGridRows = function useGridRows(apiRef, props) {
         return _extends({}, state, {
           rows: getRowsStateFromCache({
             apiRef: apiRef,
-            previousTree: gridRowTreeSelector(apiRef),
             rowCountProp: props.rowCount,
-            loadingProp: props.loading
+            loadingProp: props.loading,
+            previousTree: gridRowTreeSelector(apiRef),
+            previousTreeDepths: gridRowTreeDepthsSelector(apiRef)
           })
         });
       });
@@ -75,7 +91,7 @@ export var useGridRows = function useGridRows(apiRef, props) {
       timeout.current = null;
     }
 
-    apiRef.current.unstable_caches.rows = newCache;
+    apiRef.current.unstable_caches.rows = cache;
 
     if (!throttle) {
       run();
@@ -97,79 +113,45 @@ export var useGridRows = function useGridRows(apiRef, props) {
 
   var setRows = React.useCallback(function (rows) {
     logger.debug("Updating all rows, new length ".concat(rows.length));
-    throttledRowsChange(createRowsInternalCache({
-      rows: rows,
-      getRowId: props.getRowId,
-      loading: props.loading
-    }), true);
+    throttledRowsChange({
+      cache: createRowsInternalCache({
+        rows: rows,
+        getRowId: props.getRowId,
+        loading: props.loading
+      }),
+      throttle: true
+    });
   }, [logger, props.getRowId, props.loading, throttledRowsChange]);
   var updateRows = React.useCallback(function (updates) {
     if (props.signature === GridSignature.DataGrid && updates.length > 1) {
       // TODO: Add test with direct call to `apiRef.current.updateRows` in DataGrid after enabling the `apiRef` on the free plan.
       throw new Error(["MUI: You can't update several rows at once in `apiRef.current.updateRows` on the DataGrid.", 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
-    } // we remove duplicate updates. A server can batch updates, and send several updates for the same row in one fn call.
-
-
-    var uniqueUpdates = new Map();
-    updates.forEach(function (update) {
-      var id = getRowIdFromRowModel(update, props.getRowId, 'A row was provided without id when calling updateRows():');
+    }
 
-      if (uniqueUpdates.has(id)) {
-        uniqueUpdates.set(id, _extends({}, uniqueUpdates.get(id), update));
-      } else {
-        uniqueUpdates.set(id, update);
-      }
+    var cache = updateCacheWithNewRows({
+      updates: updates,
+      getRowId: props.getRowId,
+      previousCache: apiRef.current.unstable_caches.rows
     });
-    var deletedRowIds = [];
-    var prevCache = apiRef.current.unstable_caches.rows;
-    var newCache = {
-      rowsBeforePartialUpdates: prevCache.rowsBeforePartialUpdates,
-      loadingPropBeforePartialUpdates: prevCache.loadingPropBeforePartialUpdates,
-      idRowsLookup: _extends({}, prevCache.idRowsLookup),
-      idToIdLookup: _extends({}, prevCache.idToIdLookup),
-      ids: _toConsumableArray(prevCache.ids)
-    };
-    uniqueUpdates.forEach(function (partialRow, id) {
-      // eslint-disable-next-line no-underscore-dangle
-      if (partialRow._action === 'delete') {
-        delete newCache.idRowsLookup[id];
-        delete newCache.idToIdLookup[id];
-        deletedRowIds.push(id);
-        return;
-      }
-
-      var oldRow = apiRef.current.getRow(id);
-
-      if (!oldRow) {
-        newCache.idRowsLookup[id] = partialRow;
-        newCache.idToIdLookup[id] = id;
-        newCache.ids.push(id);
-        return;
-      }
-
-      newCache.idRowsLookup[id] = _extends({}, apiRef.current.getRow(id), partialRow);
+    throttledRowsChange({
+      cache: cache,
+      throttle: true
     });
-
-    if (deletedRowIds.length > 0) {
-      newCache.ids = newCache.ids.filter(function (id) {
-        return !deletedRowIds.includes(id);
-      });
-    }
-
-    throttledRowsChange(newCache, true);
   }, [props.signature, props.getRowId, throttledRowsChange, apiRef]);
   var getRowModels = React.useCallback(function () {
-    var allRows = gridRowIdsSelector(apiRef);
+    var dataRows = gridDataRowIdsSelector(apiRef);
     var idRowsLookup = gridRowsLookupSelector(apiRef);
-    return new Map(allRows.map(function (id) {
-      return [id, idRowsLookup[id]];
+    return new Map(dataRows.map(function (id) {
+      var _idRowsLookup$id;
+
+      return [id, (_idRowsLookup$id = idRowsLookup[id]) != null ? _idRowsLookup$id : {}];
     }));
   }, [apiRef]);
   var getRowsCount = React.useCallback(function () {
     return gridRowCountSelector(apiRef);
   }, [apiRef]);
   var getAllRowIds = React.useCallback(function () {
-    return gridRowIdsSelector(apiRef);
+    return gridDataRowIdsSelector(apiRef);
   }, [apiRef]);
   var getRowIndexRelativeToVisibleRows = React.useCallback(function (id) {
     return lookup[id];
@@ -181,6 +163,10 @@ export var useGridRows = function useGridRows(apiRef, props) {
       throw new Error("MUI: No row with id #".concat(id, " found"));
     }
 
+    if (currentNode.type !== 'group') {
+      throw new Error('MUI: Only group nodes can be expanded or collapsed');
+    }
+
     var newNode = _extends({}, currentNode, {
       childrenExpanded: isExpanded
     });
@@ -196,16 +182,16 @@ export var useGridRows = function useGridRows(apiRef, props) {
     apiRef.current.publishEvent('rowExpansionChange', newNode);
   }, [apiRef]);
   var getRowNode = React.useCallback(function (id) {
-    var _gridRowTreeSelector$;
+    var _ref3;
 
-    return (_gridRowTreeSelector$ = gridRowTreeSelector(apiRef)[id]) != null ? _gridRowTreeSelector$ : null;
+    return (_ref3 = gridRowTreeSelector(apiRef)[id]) != null ? _ref3 : null;
   }, [apiRef]);
-  var getRowGroupChildren = React.useCallback(function (_ref3) {
-    var _ref3$skipAutoGenerat = _ref3.skipAutoGeneratedRows,
-        skipAutoGeneratedRows = _ref3$skipAutoGenerat === void 0 ? true : _ref3$skipAutoGenerat,
-        groupId = _ref3.groupId,
-        applySorting = _ref3.applySorting,
-        applyFiltering = _ref3.applyFiltering;
+  var getRowGroupChildren = React.useCallback(function (_ref4) {
+    var _ref4$skipAutoGenerat = _ref4.skipAutoGeneratedRows,
+        skipAutoGeneratedRows = _ref4$skipAutoGenerat === void 0 ? true : _ref4$skipAutoGenerat,
+        groupId = _ref4.groupId,
+        applySorting = _ref4.applySorting,
+        applyFiltering = _ref4.applyFiltering;
     var tree = gridRowTreeSelector(apiRef);
     var children;
 
@@ -224,9 +210,8 @@ export var useGridRows = function useGridRows(apiRef, props) {
 
       for (var index = startIndex; index < sortedRowIds.length && tree[sortedRowIds[index]].depth > groupNode.depth; index += 1) {
         var id = sortedRowIds[index];
-        var node = tree[id];
 
-        if (!skipAutoGeneratedRows || !node.isAutoGenerated) {
+        if (!skipAutoGeneratedRows || !isAutoGeneratedRow(tree[id])) {
           children.push(id);
         }
       }
@@ -244,24 +229,41 @@ export var useGridRows = function useGridRows(apiRef, props) {
     return children;
   }, [apiRef]);
   var setRowIndex = React.useCallback(function (rowId, targetIndex) {
-    var allRows = gridRowIdsSelector(apiRef);
-    var oldIndex = allRows.findIndex(function (row) {
-      return row === rowId;
-    });
+    var node = apiRef.current.getRowNode(rowId);
 
-    if (oldIndex === -1 || oldIndex === targetIndex) {
-      return;
+    if (!node) {
+      throw new Error("MUI: No row with id #".concat(rowId, " found"));
     }
 
-    logger.debug("Moving row ".concat(rowId, " to index ").concat(targetIndex));
+    if (node.parent !== GRID_ROOT_GROUP_ID) {
+      throw new Error("MUI: The row reordering do not support reordering of grouped rows yet");
+    }
 
-    var updatedRows = _toConsumableArray(allRows);
+    if (node.type !== 'leaf') {
+      throw new Error("MUI: The row reordering do not support reordering of footer or grouping rows");
+    }
 
-    updatedRows.splice(targetIndex, 0, updatedRows.splice(oldIndex, 1)[0]);
     apiRef.current.setState(function (state) {
+      var group = gridRowTreeSelector(state, apiRef.current.instanceId)[GRID_ROOT_GROUP_ID];
+      var allRows = group.children;
+      var oldIndex = allRows.findIndex(function (row) {
+        return row === rowId;
+      });
+
+      if (oldIndex === -1 || oldIndex === targetIndex) {
+        return state;
+      }
+
+      logger.debug("Moving row ".concat(rowId, " to index ").concat(targetIndex));
+
+      var updatedRows = _toConsumableArray(allRows);
+
+      updatedRows.splice(targetIndex, 0, updatedRows.splice(oldIndex, 1)[0]);
       return _extends({}, state, {
         rows: _extends({}, state.rows, {
-          ids: updatedRows
+          tree: _extends({}, state.rows.tree, _defineProperty({}, GRID_ROOT_GROUP_ID, _extends({}, group, {
+            children: updatedRows
+          })))
         })
       });
     });
@@ -276,55 +278,59 @@ export var useGridRows = function useGridRows(apiRef, props) {
       return;
     }
 
-    var allRows = gridRowIdsSelector(apiRef);
+    var treeDepth = gridRowMaximumTreeDepthSelector(apiRef);
 
-    var updatedRows = _toConsumableArray(allRows);
+    if (treeDepth > 1) {
+      throw new Error('`apiRef.current.unstable_replaceRows` is not compatible with tree data and row grouping');
+    }
 
-    var idRowsLookup = gridRowsLookupSelector(apiRef);
-    var idToIdLookup = gridRowsIdToIdLookupSelector(apiRef);
-    var tree = gridRowTreeSelector(apiRef);
+    var tree = _extends({}, gridRowTreeSelector(apiRef));
 
-    var updatedIdRowsLookup = _extends({}, idRowsLookup);
+    var dataRowIdToModelLookup = _extends({}, gridRowsLookupSelector(apiRef));
 
-    var updatedIdToIdLookup = _extends({}, idToIdLookup);
+    var dataRowIdToIdLookup = _extends({}, gridRowsDataRowIdToIdLookupSelector(apiRef));
 
-    var updatedTree = _extends({}, tree);
+    var rootGroup = tree[GRID_ROOT_GROUP_ID];
 
-    var newRowEntries = newRows.map(function (newRowModel) {
-      var rowId = getRowIdFromRowModel(newRowModel, props.getRowId, 'A row was provided without id when calling replaceRows().');
-      return {
-        id: rowId,
-        model: newRowModel
-      };
-    });
-    newRowEntries.forEach(function (row, index) {
-      var _updatedRows$splice = updatedRows.splice(firstRowToRender + index, 1, row.id),
-          _updatedRows$splice2 = _slicedToArray(_updatedRows$splice, 1),
-          replacedRowId = _updatedRows$splice2[0];
-
-      delete updatedIdRowsLookup[replacedRowId];
-      delete updatedIdToIdLookup[replacedRowId];
-      delete updatedTree[replacedRowId];
-    });
-    newRowEntries.forEach(function (row) {
+    var rootGroupChildren = _toConsumableArray(rootGroup.children);
+
+    for (var i = 0; i < newRows.length; i += 1) {
+      var rowModel = newRows[i];
+      var rowId = getRowIdFromRowModel(rowModel, props.getRowId, 'A row was provided without id when calling replaceRows().');
+
+      var _rootGroupChildren$sp = rootGroupChildren.splice(firstRowToRender + i, 1, rowId),
+          _rootGroupChildren$sp2 = _slicedToArray(_rootGroupChildren$sp, 1),
+          replacedRowId = _rootGroupChildren$sp2[0];
+
+      delete dataRowIdToModelLookup[replacedRowId];
+      delete dataRowIdToIdLookup[replacedRowId];
+      delete tree[replacedRowId];
       var rowTreeNodeConfig = {
-        id: row.id,
-        parent: null,
+        id: rowId,
         depth: 0,
-        groupingKey: null,
-        groupingField: null
+        parent: GRID_ROOT_GROUP_ID,
+        type: 'leaf',
+        groupingKey: null
       };
-      updatedIdRowsLookup[row.id] = row.model;
-      updatedIdToIdLookup[row.id] = row.id;
-      updatedTree[row.id] = rowTreeNodeConfig;
+      dataRowIdToModelLookup[rowId] = rowModel;
+      dataRowIdToIdLookup[rowId] = rowId;
+      tree[rowId] = rowTreeNodeConfig;
+    }
+
+    tree[GRID_ROOT_GROUP_ID] = _extends({}, rootGroup, {
+      children: rootGroupChildren
+    }); // Removes potential remaining skeleton rows from the dataRowIds.
+
+    var dataRowIds = rootGroupChildren.filter(function (childId) {
+      return tree[childId].type === 'leaf';
     });
     apiRef.current.setState(function (state) {
       return _extends({}, state, {
         rows: _extends({}, state.rows, {
-          idRowsLookup: updatedIdRowsLookup,
-          idToIdLookup: updatedIdToIdLookup,
-          tree: updatedTree,
-          ids: updatedRows
+          dataRowIdToModelLookup: dataRowIdToModelLookup,
+          dataRowIdToIdLookup: dataRowIdToIdLookup,
+          dataRowIds: dataRowIds,
+          tree: tree
         })
       });
     });
@@ -355,7 +361,12 @@ export var useGridRows = function useGridRows(apiRef, props) {
     if (apiRef.current.unstable_caches.rows.rowsBeforePartialUpdates === props.rows) {
       // The `props.rows` did not change since the last row grouping
       // We can use the current rows cache which contains the partial updates done recently.
-      cache = apiRef.current.unstable_caches.rows;
+      cache = _extends({}, apiRef.current.unstable_caches.rows, {
+        updates: {
+          type: 'full',
+          rows: gridDataRowIdsSelector(apiRef)
+        }
+      });
     } else {
       // The `props.rows` has changed since the last row grouping
       // We must use the new `props.rows` on the new grouping
@@ -367,7 +378,10 @@ export var useGridRows = function useGridRows(apiRef, props) {
       });
     }
 
-    throttledRowsChange(cache, false);
+    throttledRowsChange({
+      cache: cache,
+      throttle: false
+    });
   }, [logger, apiRef, props.rows, props.getRowId, props.loading, throttledRowsChange]);
   var handleStrategyProcessorChange = React.useCallback(function (methodName) {
     if (methodName === 'rowTreeCreation') {
@@ -389,13 +403,25 @@ export var useGridRows = function useGridRows(apiRef, props) {
 
   var applyHydrateRowsProcessor = React.useCallback(function () {
     apiRef.current.setState(function (state) {
+      var response = apiRef.current.unstable_applyPipeProcessors('hydrateRows', {
+        tree: gridRowTreeSelector(state, apiRef.current.instanceId),
+        treeDepths: gridRowTreeDepthsSelector(state, apiRef.current.instanceId),
+        dataRowIds: gridDataRowIdsSelector(state, apiRef.current.instanceId),
+        dataRowIdToModelLookup: gridRowsLookupSelector(state, apiRef.current.instanceId),
+        dataRowIdToIdLookup: gridRowsDataRowIdToIdLookupSelector(state, apiRef.current.instanceId)
+      });
       return _extends({}, state, {
-        rows: _extends({}, state.rows, apiRef.current.unstable_applyPipeProcessors('hydrateRows', state.rows.groupingResponseBeforeRowHydration))
+        rows: _extends({}, state.rows, response, {
+          totalTopLevelRowCount: getTopLevelRowCount({
+            tree: response.tree,
+            rowCountProp: props.rowCount
+          })
+        })
       });
     });
     apiRef.current.publishEvent('rowsSet');
     apiRef.current.forceUpdate();
-  }, [apiRef]);
+  }, [apiRef, props.rowCount]);
   useGridRegisterPipeApplier(apiRef, 'hydrateRows', applyHydrateRowsProcessor);
   useGridApiMethod(apiRef, rowApi, 'GridRowApi');
   /**
@@ -439,10 +465,13 @@ export var useGridRows = function useGridRows(apiRef, props) {
     }
 
     logger.debug("Updating all rows, new length ".concat(props.rows.length));
-    throttledRowsChange(createRowsInternalCache({
-      rows: props.rows,
-      getRowId: props.getRowId,
-      loading: props.loading
-    }), false);
+    throttledRowsChange({
+      cache: createRowsInternalCache({
+        rows: props.rows,
+        getRowId: props.getRowId,
+        loading: props.loading
+      }),
+      throttle: false
+    });
   }, [props.rows, props.rowCount, props.getRowId, props.loading, logger, throttledRowsChange, apiRef]);
 };

package/legacy/hooks/features/rows/useGridRowsPreProcessors.js

@@ -1,39 +1,94 @@
+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_DEFAULT_STRATEGY, useGridRegisterStrategyProcessor } from '../../core/strategyProcessing';
+import { buildRootGroup, GRID_ROOT_GROUP_ID } from './gridRowsUtils';
 
-var flatRowTreeCreationMethod = function flatRowTreeCreationMethod(_ref) {
-  var ids = _ref.ids,
-      idRowsLookup = _ref.idRowsLookup,
-      idToIdLookup = _ref.idToIdLookup,
-      previousTree = _ref.previousTree;
-  var tree = {};
-
-  for (var i = 0; i < ids.length; i += 1) {
-    var rowId = ids[i];
-
-    if (previousTree && previousTree[rowId] && previousTree[rowId].depth === 0 && previousTree[rowId].parent == null && // pinned row can be unpinned
-    !previousTree[rowId].isPinned) {
-      tree[rowId] = previousTree[rowId];
-    } else {
-      tree[rowId] = {
-        id: rowId,
-        depth: 0,
-        parent: null,
-        groupingKey: '',
-        groupingField: null
-      };
-    }
+var createFlatRowTree = function createFlatRowTree(rows) {
+  var tree = _defineProperty({}, GRID_ROOT_GROUP_ID, _extends({}, buildRootGroup(), {
+    children: rows
+  }));
+
+  for (var i = 0; i < rows.length; i += 1) {
+    var rowId = rows[i];
+    tree[rowId] = {
+      id: rowId,
+      depth: 0,
+      parent: GRID_ROOT_GROUP_ID,
+      type: 'leaf',
+      groupingKey: null
+    };
   }
 
   return {
     groupingName: GRID_DEFAULT_STRATEGY,
     tree: tree,
-    treeDepth: 1,
-    idRowsLookup: idRowsLookup,
-    idToIdLookup: idToIdLookup,
-    ids: ids
+    treeDepths: {
+      0: rows.length
+    },
+    dataRowIds: rows
   };
 };
 
+var updateFlatRowTree = function updateFlatRowTree(_ref) {
+  var previousTree = _ref.previousTree,
+      actions = _ref.actions;
+
+  var tree = _extends({}, previousTree);
+
+  var idsToRemoveFromRootGroup = {};
+
+  for (var i = 0; i < actions.remove.length; i += 1) {
+    var idToDelete = actions.remove[i];
+    idsToRemoveFromRootGroup[idToDelete] = true;
+    delete tree[idToDelete];
+  }
+
+  for (var _i = 0; _i < actions.insert.length; _i += 1) {
+    var idToInsert = actions.insert[_i];
+    tree[idToInsert] = {
+      id: idToInsert,
+      depth: 0,
+      parent: GRID_ROOT_GROUP_ID,
+      type: 'leaf',
+      groupingKey: null
+    };
+  } // TODO rows v6: Support row unpinning
+
+
+  var rootGroup = tree[GRID_ROOT_GROUP_ID];
+  var rootGroupChildren = [].concat(_toConsumableArray(rootGroup.children), _toConsumableArray(actions.insert));
+
+  if (Object.values(idsToRemoveFromRootGroup).length) {
+    rootGroupChildren = rootGroupChildren.filter(function (id) {
+      return !idsToRemoveFromRootGroup[id];
+    });
+  }
+
+  tree[GRID_ROOT_GROUP_ID] = _extends({}, rootGroup, {
+    children: rootGroupChildren
+  });
+  return {
+    groupingName: GRID_DEFAULT_STRATEGY,
+    tree: tree,
+    treeDepths: {
+      0: rootGroupChildren.length
+    },
+    dataRowIds: rootGroupChildren
+  };
+};
+
+var flatRowTreeCreationMethod = function flatRowTreeCreationMethod(params) {
+  if (params.updates.type === 'full') {
+    return createFlatRowTree(params.updates.rows);
+  }
+
+  return updateFlatRowTree({
+    previousTree: params.previousTree,
+    actions: params.updates.actions
+  });
+};
+
 export var useGridRowsPreProcessors = function useGridRowsPreProcessors(apiRef) {
   useGridRegisterStrategyProcessor(apiRef, GRID_DEFAULT_STRATEGY, 'rowTreeCreation', flatRowTreeCreationMethod);
 };

package/legacy/hooks/features/selection/useGridSelection.js

@@ -126,7 +126,7 @@ export var useGridSelection = function useGridSelection(apiRef, props) {
 
     var rowNode = apiRef.current.getRowNode(id);
 
-    if ((rowNode == null ? void 0 : rowNode.position) === 'footer' || rowNode != null && rowNode.isPinned) {
+    if ((rowNode == null ? void 0 : rowNode.type) === 'footer' || (rowNode == null ? void 0 : rowNode.type) === 'pinnedRow') {
       return false;
     }
 
@@ -296,7 +296,7 @@ export var useGridSelection = function useGridSelection(apiRef, props) {
       }
     }
 
-    if (params.rowNode.isPinned) {
+    if (params.rowNode.type === 'pinnedRow') {
       return;
     }
 

package/legacy/hooks/features/sorting/gridSortingSelector.js

@@ -21,11 +21,14 @@ export var gridSortedRowIdsSelector = createSelector(gridSortingStateSelector, f
  * @category Sorting
  */
 
-export var gridSortedRowEntriesSelector = createSelector(gridSortedRowIdsSelector, gridRowsLookupSelector, function (sortedIds, idRowsLookup) {
+export var gridSortedRowEntriesSelector = createSelector(gridSortedRowIdsSelector, gridRowsLookupSelector, // TODO rows v6: Is this the best approach ?
+function (sortedIds, idRowsLookup) {
   return sortedIds.map(function (id) {
+    var _idRowsLookup$id;
+
     return {
       id: id,
-      model: idRowsLookup[id]
+      model: (_idRowsLookup$id = idRowsLookup[id]) != null ? _idRowsLookup$id : {}
     };
   });
 });