@mui/x-tree-view 7.3.0 → 7.3.1

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.utils.js

@@ -0,0 +1,21 @@
+/**
+ * Transform the `selectedItems` model to be an array if it was a string or null.
+ * @param {string[] | string | null} model The raw model.
+ * @returns {string[]} The converted model.
+ */
+export const convertSelectedItemsToArray = model => {
+  if (Array.isArray(model)) {
+    return model;
+  }
+  if (model != null) {
+    return [model];
+  }
+  return [];
+};
+export const getLookupFromArray = array => {
+  const lookup = {};
+  array.forEach(itemId => {
+    lookup[itemId] = true;
+  });
+  return lookup;
+};

package/internals/useTreeView/useTreeView.types.d.ts

@@ -11,7 +11,7 @@ export interface UseTreeViewBaseParameters<TPlugins extends readonly TreeViewPlu
     slotProps: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'slotProps'>;
 }
 export type UseTreeViewDefaultizedParameters<TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]> = UseTreeViewBaseParameters<TPlugins> & MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'defaultizedParams'>;
-export interface UseTreeViewRootSlotProps extends Pick<React.HTMLAttributes<HTMLUListElement>, 'onFocus' | 'onBlur' | 'onKeyDown' | 'id' | 'aria-activedescendant' | 'aria-multiselectable' | 'role' | 'tabIndex'> {
+export interface UseTreeViewRootSlotProps extends Pick<React.HTMLAttributes<HTMLUListElement>, 'onFocus' | 'onBlur' | 'onKeyDown' | 'id' | 'aria-multiselectable' | 'role' | 'tabIndex'> {
     ref: React.Ref<HTMLUListElement>;
 }
 export interface UseTreeViewReturnValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> {

package/internals/useTreeView/useTreeViewModels.d.ts

@@ -3,4 +3,4 @@ import { TreeViewAnyPluginSignature, TreeViewPlugin, ConvertPluginsIntoSignature
  * Implements the same behavior as `useControlled` but for several models.
  * The controlled models are never stored in the state and the state is only updated if the model is not controlled.
  */
-export declare const useTreeViewModels: <TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]>(plugins: TPlugins, props: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, "defaultizedParams">) => MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, "models">;
+export declare const useTreeViewModels: <TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]>(plugins: TPlugins, props: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'defaultizedParams'>) => MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, "models">;

package/internals/utils/extractPluginParamsFromProps.d.ts

@@ -8,7 +8,7 @@ export declare const extractPluginParamsFromProps: <TPlugins extends readonly Tr
 }>({ props: { slots, slotProps, apiRef, ...props }, plugins, rootRef, }: {
     props: TProps;
     plugins: TPlugins;
-    rootRef?: React.Ref<HTMLUListElement> | undefined;
+    rootRef?: React.Ref<HTMLUListElement>;
 }) => {
     pluginParams: UseTreeViewBaseParameters<TPlugins> & MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, "params">;
     slots: TSlots | undefined;

package/internals/utils/publishTreeViewEvent.d.ts

@@ -2,4 +2,4 @@ import { UseTreeViewInstanceEventsInstance } from '../corePlugins/useTreeViewIns
 import { TreeViewAnyPluginSignature, TreeViewUsedEvents } from '../models';
 export declare const publishTreeViewEvent: <Instance extends UseTreeViewInstanceEventsInstance & {
     $$signature: TreeViewAnyPluginSignature;
-}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergePluginsProperty<[import("../corePlugins").TreeViewCorePluginsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, params: TreeViewUsedEvents<Instance["$$signature"]>[E]["params"]) => void;
+}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergePluginsProperty<[import("../corePlugins").TreeViewCorePluginsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, params: TreeViewUsedEvents<Instance['$$signature']>[E]['params']) => void;

package/internals/utils/tree.d.ts

@@ -5,4 +5,20 @@ export declare const getPreviousNavigableItem: (instance: TreeViewInstance<[UseT
 export declare const getNextNavigableItem: (instance: TreeViewInstance<[UseTreeViewExpansionSignature, UseTreeViewItemsSignature]>, itemId: string) => string | null;
 export declare const getLastNavigableItem: (instance: TreeViewInstance<[UseTreeViewExpansionSignature, UseTreeViewItemsSignature]>) => string;
 export declare const getFirstNavigableItem: (instance: TreeViewInstance<[UseTreeViewItemsSignature]>) => string;
-export declare const getNavigableItemsInRange: (instance: TreeViewInstance<[UseTreeViewItemsSignature, UseTreeViewExpansionSignature]>, itemAId: string, itemBId: string) => string[];
+/**
+ * This is used to determine the start and end of a selection range so
+ * we can get the items between the two border items.
+ *
+ * It finds the items' common ancestor using
+ * a naive implementation of a lowest common ancestor algorithm
+ * (https://en.wikipedia.org/wiki/Lowest_common_ancestor).
+ * Then compares the ancestor's 2 children that are ancestors of itemA and ItemB
+ * so we can compare their indexes to work out which item comes first in a depth first search.
+ * (https://en.wikipedia.org/wiki/Depth-first_search)
+ *
+ * Another way to put it is which item is shallower in a trémaux tree
+ * https://en.wikipedia.org/wiki/Tr%C3%A9maux_tree
+ */
+export declare const findOrderInTremauxTree: (instance: TreeViewInstance<[UseTreeViewItemsSignature]>, itemAId: string, itemBId: string) => string[];
+export declare const getNonDisabledItemsInRange: (instance: TreeViewInstance<[UseTreeViewItemsSignature, UseTreeViewExpansionSignature]>, itemAId: string, itemBId: string) => string[];
+export declare const getAllNavigableItems: (instance: TreeViewInstance<[UseTreeViewItemsSignature, UseTreeViewExpansionSignature]>) => string[];

package/internals/utils/tree.js

@@ -84,7 +84,7 @@ export const getFirstNavigableItem = instance => instance.getItemOrderedChildren
  * Another way to put it is which item is shallower in a trémaux tree
  * https://en.wikipedia.org/wiki/Tr%C3%A9maux_tree
  */
-const findOrderInTremauxTree = (instance, itemAId, itemBId) => {
+export const findOrderInTremauxTree = (instance, itemAId, itemBId) => {
   if (itemAId === itemBId) {
     return [itemAId, itemBId];
   }
@@ -125,13 +125,43 @@ const findOrderInTremauxTree = (instance, itemAId, itemBId) => {
   const bSide = bFamily[bFamily.indexOf(commonAncestor) - 1];
   return ancestorFamily.indexOf(aSide) < ancestorFamily.indexOf(bSide) ? [itemAId, itemBId] : [itemBId, itemAId];
 };
-export const getNavigableItemsInRange = (instance, itemAId, itemBId) => {
+export const getNonDisabledItemsInRange = (instance, itemAId, itemBId) => {
+  const getNextItem = itemId => {
+    // If the item is expanded and has some children, return the first of them.
+    if (instance.isItemExpandable(itemId) && instance.isItemExpanded(itemId)) {
+      return instance.getItemOrderedChildrenIds(itemId)[0];
+    }
+    let itemMeta = instance.getItemMeta(itemId);
+    while (itemMeta != null) {
+      // Try to find the first navigable sibling after the current item.
+      const siblings = instance.getItemOrderedChildrenIds(itemMeta.parentId);
+      const currentItemIndex = instance.getItemIndex(itemMeta.id);
+      if (currentItemIndex < siblings.length - 1) {
+        return siblings[currentItemIndex + 1];
+      }
+
+      // If the item is the last of its siblings, go up a level to the parent and try again.
+      itemMeta = instance.getItemMeta(itemMeta.parentId);
+    }
+    throw new Error('Invalid range');
+  };
   const [first, last] = findOrderInTremauxTree(instance, itemAId, itemBId);
   const items = [first];
   let current = first;
   while (current !== last) {
-    current = getNextNavigableItem(instance, current);
-    items.push(current);
+    current = getNextItem(current);
+    if (!instance.isItemDisabled(current)) {
+      items.push(current);
+    }
   }
   return items;
+};
+export const getAllNavigableItems = instance => {
+  let item = getFirstNavigableItem(instance);
+  const navigableItems = [];
+  while (item != null) {
+    navigableItems.push(item);
+    item = getNextNavigableItem(instance, item);
+  }
+  return navigableItems;
 };

package/modern/TreeItem/TreeItem.js

@@ -19,8 +19,7 @@ import { treeItemClasses, getTreeItemUtilityClass } from './treeItemClasses';
 import { useTreeViewContext } from '../internals/TreeViewProvider/useTreeViewContext';
 import { TreeViewCollapseIcon, TreeViewExpandIcon } from '../icons';
 import { TreeItem2Provider } from '../TreeItem2Provider';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const useUtilityClasses = ownerState => {
   const {
     classes

package/modern/TreeItem/TreeItemContent.js

@@ -5,8 +5,7 @@ import * as React from 'react';
 import PropTypes from 'prop-types';
 import clsx from 'clsx';
 import { useTreeItemState } from './useTreeItemState';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * @ignore - internal component.
  */

package/modern/TreeItem/useTreeItemState.js

@@ -32,9 +32,7 @@ export function useTreeItemState(itemId) {
       const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
       if (multiple) {
         if (event.shiftKey) {
-          instance.selectRange(event, {
-            end: itemId
-          });
+          instance.expandSelectionRange(event, itemId);
         } else {
           instance.selectItem(event, itemId, true);
         }

package/modern/TreeItem2/TreeItem2.js

@@ -14,8 +14,7 @@ import { unstable_useTreeItem2 as useTreeItem2 } from '../useTreeItem2';
 import { getTreeItemUtilityClass, treeItemClasses } from '../TreeItem';
 import { TreeItem2Icon } from '../TreeItem2Icon';
 import { TreeItem2Provider } from '../TreeItem2Provider';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export const TreeItem2Root = styled('li', {
   name: 'MuiTreeItem2',
   slot: 'Root',

package/modern/hooks/useTreeItem2Utils/useTreeItem2Utils.js

@@ -40,9 +40,7 @@ export const useTreeItem2Utils = ({
     const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
     if (multiple) {
       if (event.shiftKey) {
-        instance.selectRange(event, {
-          end: itemId
-        });
+        instance.expandSelectionRange(event, itemId);
       } else {
         instance.selectItem(event, itemId, true);
       }

package/modern/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-tree-view v7.3.0
+ * @mui/x-tree-view v7.3.1
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/modern/internals/plugins/useTreeViewFocus/useTreeViewFocus.js

@@ -105,12 +105,9 @@ export const useTreeViewFocus = ({
       instance.focusDefaultItem(event);
     }
   };
-  const focusedItem = instance.getItemMeta(state.focusedItemId);
-  const activeDescendant = focusedItem ? instance.getTreeItemIdAttribute(focusedItem.id, focusedItem.idAttribute) : null;
   return {
     getRootProps: otherHandlers => ({
-      onFocus: createRootHandleFocus(otherHandlers),
-      'aria-activedescendant': activeDescendant ?? undefined
+      onFocus: createRootHandleFocus(otherHandlers)
     }),
     publicAPI: {
       focusItem

package/modern/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js

@@ -5,14 +5,6 @@ import { getFirstNavigableItem, getLastNavigableItem, getNextNavigableItem, getP
 function isPrintableCharacter(string) {
   return !!string && string.length === 1 && !!string.match(/\S/);
 }
-function findNextFirstChar(firstChars, startIndex, char) {
-  for (let i = startIndex; i < firstChars.length; i += 1) {
-    if (char === firstChars[i]) {
-      return i;
-    }
-  }
-  return -1;
-}
 export const useTreeViewKeyboardNavigation = ({
   instance,
   params,
@@ -35,42 +27,29 @@ export const useTreeViewKeyboardNavigation = ({
     Object.values(state.items.itemMetaMap).forEach(processItem);
     firstCharMap.current = newFirstCharMap;
   }, [state.items.itemMetaMap, params.getItemId, instance]);
-  const getFirstMatchingItem = (itemId, firstChar) => {
-    let start;
-    let index;
-    const lowercaseChar = firstChar.toLowerCase();
-    const firstCharIds = [];
-    const firstChars = [];
-    // This really only works since the ids are strings
-    Object.keys(firstCharMap.current).forEach(mapItemId => {
-      const map = instance.getItemMeta(mapItemId);
-      const visible = map.parentId ? instance.isItemExpanded(map.parentId) : true;
-      const shouldBeSkipped = params.disabledItemsFocusable ? false : instance.isItemDisabled(mapItemId);
-      if (visible && !shouldBeSkipped) {
-        firstCharIds.push(mapItemId);
-        firstChars.push(firstCharMap.current[mapItemId]);
+  const getFirstMatchingItem = (itemId, query) => {
+    const cleanQuery = query.toLowerCase();
+    const getNextItem = itemIdToCheck => {
+      const nextItemId = getNextNavigableItem(instance, itemIdToCheck);
+      // We reached the end of the tree, check from the beginning
+      if (nextItemId === null) {
+        return getFirstNavigableItem(instance);
+      }
+      return nextItemId;
+    };
+    let matchingItemId = null;
+    let currentItemId = getNextItem(itemId);
+    const checkedItems = {};
+    // The "!checkedItems[currentItemId]" condition avoids an infinite loop when there is no matching item.
+    while (matchingItemId == null && !checkedItems[currentItemId]) {
+      if (firstCharMap.current[currentItemId] === cleanQuery) {
+        matchingItemId = currentItemId;
+      } else {
+        checkedItems[currentItemId] = true;
+        currentItemId = getNextItem(currentItemId);
       }
-    });
-
-    // Get start index for search based on position of currentItem
-    start = firstCharIds.indexOf(itemId) + 1;
-    if (start >= firstCharIds.length) {
-      start = 0;
-    }
-
-    // Check remaining slots in the menu
-    index = findNextFirstChar(firstChars, start, lowercaseChar);
-
-    // If not found in remaining slots, check from beginning
-    if (index === -1) {
-      index = findNextFirstChar(firstChars, 0, lowercaseChar);
-    }
-
-    // If a match was found...
-    if (index > -1) {
-      return firstCharIds[index];
     }
-    return null;
+    return matchingItemId;
   };
   const canToggleItemSelection = itemId => !params.disableSelection && !instance.isItemDisabled(itemId);
   const canToggleItemExpansion = itemId => {
@@ -95,9 +74,7 @@ export const useTreeViewKeyboardNavigation = ({
         {
           event.preventDefault();
           if (params.multiSelect && event.shiftKey) {
-            instance.selectRange(event, {
-              end: itemId
-            });
+            instance.expandSelectionRange(event, itemId);
           } else if (params.multiSelect) {
             instance.selectItem(event, itemId, true);
           } else {
@@ -136,10 +113,7 @@ export const useTreeViewKeyboardNavigation = ({
             // Multi select behavior when pressing Shift + ArrowDown
             // Toggles the selection state of the next item
             if (params.multiSelect && event.shiftKey && canToggleItemSelection(nextItem)) {
-              instance.selectRange(event, {
-                end: nextItem,
-                current: itemId
-              }, true);
+              instance.selectItemFromArrowNavigation(event, itemId, nextItem);
             }
           }
           break;
@@ -156,10 +130,7 @@ export const useTreeViewKeyboardNavigation = ({
             // Multi select behavior when pressing Shift + ArrowUp
             // Toggles the selection state of the previous item
             if (params.multiSelect && event.shiftKey && canToggleItemSelection(previousItem)) {
-              instance.selectRange(event, {
-                end: previousItem,
-                current: itemId
-              }, true);
+              instance.selectItemFromArrowNavigation(event, itemId, previousItem);
             }
           }
           break;
@@ -202,12 +173,12 @@ export const useTreeViewKeyboardNavigation = ({
       // Focuses the first item in the tree
       case key === 'Home':
         {
-          instance.focusItem(event, getFirstNavigableItem(instance));
-
           // Multi select behavior when pressing Ctrl + Shift + Home
           // Selects the focused item and all items up to the first item.
           if (canToggleItemSelection(itemId) && params.multiSelect && ctrlPressed && event.shiftKey) {
-            instance.rangeSelectToFirst(event, itemId);
+            instance.selectRangeFromStartToItem(event, itemId);
+          } else {
+            instance.focusItem(event, getFirstNavigableItem(instance));
           }
           event.preventDefault();
           break;
@@ -216,12 +187,12 @@ export const useTreeViewKeyboardNavigation = ({
       // Focuses the last item in the tree
       case key === 'End':
         {
-          instance.focusItem(event, getLastNavigableItem(instance));
-
           // Multi select behavior when pressing Ctrl + Shirt + End
           // Selects the focused item and all the items down to the last item.
           if (canToggleItemSelection(itemId) && params.multiSelect && ctrlPressed && event.shiftKey) {
-            instance.rangeSelectToLast(event, itemId);
+            instance.selectRangeFromItemToEnd(event, itemId);
+          } else {
+            instance.focusItem(event, getLastNavigableItem(instance));
           }
           event.preventDefault();
           break;
@@ -239,10 +210,7 @@ export const useTreeViewKeyboardNavigation = ({
       // Selects all the items
       case key === 'a' && ctrlPressed && params.multiSelect && !params.disableSelection:
         {
-          instance.selectRange(event, {
-            start: getFirstNavigableItem(instance),
-            end: getLastNavigableItem(instance)
-          });
+          instance.selectAllNavigableItems(event);
           event.preventDefault();
           break;
         }

package/modern/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -1,14 +1,25 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { getFirstNavigableItem, getLastNavigableItem, getNavigableItemsInRange } from '../../utils/tree';
+import { findOrderInTremauxTree, getAllNavigableItems, getFirstNavigableItem, getLastNavigableItem, getNonDisabledItemsInRange } from '../../utils/tree';
+import { convertSelectedItemsToArray, getLookupFromArray } from './useTreeViewSelection.utils';
 export const useTreeViewSelection = ({
   instance,
   params,
   models
 }) => {
   const lastSelectedItem = React.useRef(null);
-  const lastSelectionWasRange = React.useRef(false);
-  const currentRangeSelection = React.useRef([]);
+  const lastSelectedRange = React.useRef({});
+  const selectedItemsMap = React.useMemo(() => {
+    const temp = new Map();
+    if (Array.isArray(models.selectedItems.value)) {
+      models.selectedItems.value.forEach(id => {
+        temp.set(id, true);
+      });
+    } else if (models.selectedItems.value != null) {
+      temp.set(models.selectedItems.value, true);
+    }
+    return temp;
+  }, [models.selectedItems.value]);
   const setSelectedItems = (event, newSelectedItems) => {
     if (params.onItemSelectionToggle) {
       if (params.multiSelect) {
@@ -34,115 +45,90 @@ export const useTreeViewSelection = ({
     }
     models.selectedItems.setControlledValue(newSelectedItems);
   };
-  const isItemSelected = itemId => Array.isArray(models.selectedItems.value) ? models.selectedItems.value.indexOf(itemId) !== -1 : models.selectedItems.value === itemId;
+  const isItemSelected = itemId => selectedItemsMap.has(itemId);
   const selectItem = (event, itemId, multiple = false) => {
     if (params.disableSelection) {
       return;
     }
+    let newSelected;
     if (multiple) {
-      if (Array.isArray(models.selectedItems.value)) {
-        let newSelected;
-        if (models.selectedItems.value.indexOf(itemId) !== -1) {
-          newSelected = models.selectedItems.value.filter(id => id !== itemId);
-        } else {
-          newSelected = [itemId].concat(models.selectedItems.value);
-        }
-        setSelectedItems(event, newSelected);
+      const cleanSelectedItems = convertSelectedItemsToArray(models.selectedItems.value);
+      if (instance.isItemSelected(itemId)) {
+        newSelected = cleanSelectedItems.filter(id => id !== itemId);
+      } else {
+        newSelected = [itemId].concat(cleanSelectedItems);
       }
     } else {
-      const newSelected = params.multiSelect ? [itemId] : itemId;
-      setSelectedItems(event, newSelected);
+      newSelected = params.multiSelect ? [itemId] : itemId;
     }
+    setSelectedItems(event, newSelected);
     lastSelectedItem.current = itemId;
-    lastSelectionWasRange.current = false;
-    currentRangeSelection.current = [];
+    lastSelectedRange.current = {};
   };
-  const handleRangeArrowSelect = (event, items) => {
-    let base = models.selectedItems.value.slice();
-    const {
-      start,
-      next,
-      current
-    } = items;
-    if (!next || !current) {
+  const selectRange = (event, [start, end]) => {
+    if (params.disableSelection || !params.multiSelect) {
       return;
     }
-    if (currentRangeSelection.current.indexOf(current) === -1) {
-      currentRangeSelection.current = [];
+    let newSelectedItems = convertSelectedItemsToArray(models.selectedItems.value).slice();
+
+    // If the last selection was a range selection,
+    // remove the items that were part of the last range from the model
+    if (Object.keys(lastSelectedRange.current).length > 0) {
+      newSelectedItems = newSelectedItems.filter(id => !lastSelectedRange.current[id]);
     }
-    if (lastSelectionWasRange.current) {
-      if (currentRangeSelection.current.indexOf(next) !== -1) {
-        base = base.filter(id => id === start || id !== current);
-        currentRangeSelection.current = currentRangeSelection.current.filter(id => id === start || id !== current);
-      } else {
-        base.push(next);
-        currentRangeSelection.current.push(next);
-      }
-    } else {
-      base.push(next);
-      currentRangeSelection.current.push(current, next);
-    }
-    setSelectedItems(event, base);
+
+    // Add to the model the items that are part of the new range and not already part of the model.
+    const selectedItemsLookup = getLookupFromArray(newSelectedItems);
+    const range = getNonDisabledItemsInRange(instance, start, end);
+    const itemsToAddToModel = range.filter(id => !selectedItemsLookup[id]);
+    newSelectedItems = newSelectedItems.concat(itemsToAddToModel);
+    setSelectedItems(event, newSelectedItems);
+    lastSelectedRange.current = getLookupFromArray(range);
   };
-  const handleRangeSelect = (event, items) => {
-    let base = models.selectedItems.value.slice();
-    const {
-      start,
-      end
-    } = items;
-    // If last selection was a range selection ignore items that were selected.
-    if (lastSelectionWasRange.current) {
-      base = base.filter(id => currentRangeSelection.current.indexOf(id) === -1);
+  const expandSelectionRange = (event, itemId) => {
+    if (lastSelectedItem.current != null) {
+      const [start, end] = findOrderInTremauxTree(instance, itemId, lastSelectedItem.current);
+      selectRange(event, [start, end]);
     }
-    let range = getNavigableItemsInRange(instance, start, end);
-    range = range.filter(item => !instance.isItemDisabled(item));
-    currentRangeSelection.current = range;
-    let newSelected = base.concat(range);
-    newSelected = newSelected.filter((id, i) => newSelected.indexOf(id) === i);
-    setSelectedItems(event, newSelected);
   };
-  const selectRange = (event, items, stacked = false) => {
-    if (params.disableSelection) {
+  const selectRangeFromStartToItem = (event, itemId) => {
+    selectRange(event, [getFirstNavigableItem(instance), itemId]);
+  };
+  const selectRangeFromItemToEnd = (event, itemId) => {
+    selectRange(event, [itemId, getLastNavigableItem(instance)]);
+  };
+  const selectAllNavigableItems = event => {
+    if (params.disableSelection || !params.multiSelect) {
       return;
     }
-    const {
-      start = lastSelectedItem.current,
-      end,
-      current
-    } = items;
-    if (stacked) {
-      handleRangeArrowSelect(event, {
-        start,
-        next: end,
-        current
-      });
-    } else if (start != null && end != null) {
-      handleRangeSelect(event, {
-        start,
-        end
-      });
-    }
-    lastSelectionWasRange.current = true;
+    const navigableItems = getAllNavigableItems(instance);
+    setSelectedItems(event, navigableItems);
+    lastSelectedRange.current = getLookupFromArray(navigableItems);
   };
-  const rangeSelectToFirst = (event, itemId) => {
-    if (!lastSelectedItem.current) {
-      lastSelectedItem.current = itemId;
+  const selectItemFromArrowNavigation = (event, currentItem, nextItem) => {
+    if (params.disableSelection || !params.multiSelect) {
+      return;
     }
-    const start = lastSelectionWasRange.current ? lastSelectedItem.current : itemId;
-    instance.selectRange(event, {
-      start,
-      end: getFirstNavigableItem(instance)
-    });
-  };
-  const rangeSelectToLast = (event, itemId) => {
-    if (!lastSelectedItem.current) {
-      lastSelectedItem.current = itemId;
+    let newSelectedItems = convertSelectedItemsToArray(models.selectedItems.value).slice();
+    if (Object.keys(lastSelectedRange.current).length === 0) {
+      newSelectedItems.push(nextItem);
+      lastSelectedRange.current = {
+        [currentItem]: true,
+        [nextItem]: true
+      };
+    } else {
+      if (!lastSelectedRange.current[currentItem]) {
+        lastSelectedRange.current = {};
+      }
+      if (lastSelectedRange.current[nextItem]) {
+        newSelectedItems = newSelectedItems.filter(id => id !== currentItem);
+        delete lastSelectedRange.current[currentItem];
+      } else {
+        newSelectedItems.push(nextItem);
+        lastSelectedRange.current[nextItem] = true;
+      }
     }
-    const start = lastSelectionWasRange.current ? lastSelectedItem.current : itemId;
-    instance.selectRange(event, {
-      start,
-      end: getLastNavigableItem(instance)
-    });
+    setSelectedItems(event, newSelectedItems);
   };
   return {
     getRootProps: () => ({
@@ -151,9 +137,11 @@ export const useTreeViewSelection = ({
     instance: {
       isItemSelected,
       selectItem,
-      selectRange,
-      rangeSelectToLast,
-      rangeSelectToFirst
+      selectAllNavigableItems,
+      expandSelectionRange,
+      selectRangeFromStartToItem,
+      selectRangeFromItemToEnd,
+      selectItemFromArrowNavigation
     },
     contextValue: {
       selection: {

package/modern/internals/plugins/useTreeViewSelection/useTreeViewSelection.utils.js

@@ -0,0 +1,21 @@
+/**
+ * Transform the `selectedItems` model to be an array if it was a string or null.
+ * @param {string[] | string | null} model The raw model.
+ * @returns {string[]} The converted model.
+ */
+export const convertSelectedItemsToArray = model => {
+  if (Array.isArray(model)) {
+    return model;
+  }
+  if (model != null) {
+    return [model];
+  }
+  return [];
+};
+export const getLookupFromArray = array => {
+  const lookup = {};
+  array.forEach(itemId => {
+    lookup[itemId] = true;
+  });
+  return lookup;
+};