@mui/x-tree-view 7.0.0-beta.7 → 7.1.0

package/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { useTheme } from '@mui/material/styles';
 import useEventCallback from '@mui/utils/useEventCallback';
-import { getFirstNode, getLastNode, getNextNode, getPreviousNode, populateInstance } from '../../useTreeView/useTreeView.utils';
+import { getFirstItem, getLastItem, getNextItem, getPreviousItem, populateInstance } from '../../useTreeView/useTreeView.utils';
 function isPrintableCharacter(string) {
   return !!string && string.length === 1 && !!string.match(/\S/);
 }
@@ -21,48 +21,39 @@ export const useTreeViewKeyboardNavigation = ({
   const theme = useTheme();
   const isRTL = theme.direction === 'rtl';
   const firstCharMap = React.useRef({});
-  const hasFirstCharMapBeenUpdatedImperatively = React.useRef(false);
   const updateFirstCharMap = useEventCallback(callback => {
-    hasFirstCharMapBeenUpdatedImperatively.current = true;
     firstCharMap.current = callback(firstCharMap.current);
   });
   React.useEffect(() => {
-    if (hasFirstCharMapBeenUpdatedImperatively.current) {
+    if (instance.areItemUpdatesPrevented()) {
       return;
     }
     const newFirstCharMap = {};
-    const processItem = item => {
-      var _item$children;
-      const getItemId = params.getItemId;
-      const nodeId = getItemId ? getItemId(item) : item.id;
-      newFirstCharMap[nodeId] = instance.getNode(nodeId).label.substring(0, 1).toLowerCase();
-      (_item$children = item.children) == null || _item$children.forEach(processItem);
+    const processItem = node => {
+      newFirstCharMap[node.id] = node.label.substring(0, 1).toLowerCase();
     };
-    params.items.forEach(processItem);
+    Object.values(state.items.nodeMap).forEach(processItem);
     firstCharMap.current = newFirstCharMap;
-  }, [params.items, params.getItemId, instance]);
-  populateInstance(instance, {
-    updateFirstCharMap
-  });
-  const getFirstMatchingNode = (nodeId, firstChar) => {
+  }, [state.items.nodeMap, 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(mapNodeId => {
-      const map = instance.getNode(mapNodeId);
-      const visible = map.parentId ? instance.isNodeExpanded(map.parentId) : true;
-      const shouldBeSkipped = params.disabledItemsFocusable ? false : instance.isNodeDisabled(mapNodeId);
+    Object.keys(firstCharMap.current).forEach(mapItemId => {
+      const map = instance.getNode(mapItemId);
+      const visible = map.parentId ? instance.isItemExpanded(map.parentId) : true;
+      const shouldBeSkipped = params.disabledItemsFocusable ? false : instance.isItemDisabled(mapItemId);
       if (visible && !shouldBeSkipped) {
-        firstCharIds.push(mapNodeId);
-        firstChars.push(firstCharMap.current[mapNodeId]);
+        firstCharIds.push(mapItemId);
+        firstChars.push(firstCharMap.current[mapItemId]);
       }
     });
 
     // Get start index for search based on position of currentItem
-    start = firstCharIds.indexOf(nodeId) + 1;
+    start = firstCharIds.indexOf(itemId) + 1;
     if (start >= firstCharIds.length) {
       start = 0;
     }
@@ -81,21 +72,17 @@ export const useTreeViewKeyboardNavigation = ({
     }
     return null;
   };
-  const canToggleNodeSelection = nodeId => !params.disableSelection && !instance.isNodeDisabled(nodeId);
-  const canToggleNodeExpansion = nodeId => {
-    return !instance.isNodeDisabled(nodeId) && instance.isNodeExpandable(nodeId);
+  const canToggleItemSelection = itemId => !params.disableSelection && !instance.isItemDisabled(itemId);
+  const canToggleItemExpansion = itemId => {
+    return !instance.isItemDisabled(itemId) && instance.isItemExpandable(itemId);
   };
 
   // ARIA specification: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/#keyboardinteraction
-  const createHandleKeyDown = otherHandlers => event => {
-    var _otherHandlers$onKeyD;
-    (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);
+  const handleItemKeyDown = (event, itemId) => {
     if (event.defaultMuiPrevented) {
       return;
     }
-
-    // If the tree is empty, there will be no focused node
-    if (event.altKey || event.currentTarget !== event.target || state.focusedNodeId == null) {
+    if (event.altKey || event.currentTarget !== event.target) {
       return;
     }
     const ctrlPressed = event.ctrlKey || event.metaKey;
@@ -103,104 +90,107 @@ export const useTreeViewKeyboardNavigation = ({
 
     // eslint-disable-next-line default-case
     switch (true) {
-      // Select the node when pressing "Space"
-      case key === ' ' && canToggleNodeSelection(state.focusedNodeId):
+      // Select the item when pressing "Space"
+      case key === ' ' && canToggleItemSelection(itemId):
         {
           event.preventDefault();
           if (params.multiSelect && event.shiftKey) {
             instance.selectRange(event, {
-              end: state.focusedNodeId
+              end: itemId
             });
           } else if (params.multiSelect) {
-            instance.selectNode(event, state.focusedNodeId, true);
+            instance.selectItem(event, itemId, true);
           } else {
-            instance.selectNode(event, state.focusedNodeId);
+            instance.selectItem(event, itemId);
           }
           break;
         }
 
-      // If the focused node has children, we expand it.
-      // If the focused node has no children, we select it.
+      // If the focused item has children, we expand it.
+      // If the focused item has no children, we select it.
       case key === 'Enter':
         {
-          if (canToggleNodeExpansion(state.focusedNodeId)) {
-            instance.toggleNodeExpansion(event, state.focusedNodeId);
+          if (canToggleItemExpansion(itemId)) {
+            instance.toggleItemExpansion(event, itemId);
             event.preventDefault();
-          } else if (canToggleNodeSelection(state.focusedNodeId)) {
+          } else if (canToggleItemSelection(itemId)) {
             if (params.multiSelect) {
               event.preventDefault();
-              instance.selectNode(event, state.focusedNodeId, true);
-            } else if (!instance.isNodeSelected(state.focusedNodeId)) {
-              instance.selectNode(event, state.focusedNodeId);
+              instance.selectItem(event, itemId, true);
+            } else if (!instance.isItemSelected(itemId)) {
+              instance.selectItem(event, itemId);
               event.preventDefault();
             }
           }
           break;
         }
 
-      // Focus the next focusable node
+      // Focus the next focusable item
       case key === 'ArrowDown':
         {
-          const nextNode = getNextNode(instance, state.focusedNodeId);
-          if (nextNode) {
+          const nextItem = getNextItem(instance, itemId);
+          if (nextItem) {
             event.preventDefault();
-            instance.focusItem(event, nextNode);
+            instance.focusItem(event, nextItem);
 
             // Multi select behavior when pressing Shift + ArrowDown
-            // Toggles the selection state of the next node
-            if (params.multiSelect && event.shiftKey && canToggleNodeSelection(nextNode)) {
+            // Toggles the selection state of the next item
+            if (params.multiSelect && event.shiftKey && canToggleItemSelection(nextItem)) {
               instance.selectRange(event, {
-                end: nextNode,
-                current: state.focusedNodeId
+                end: nextItem,
+                current: itemId
               }, true);
             }
           }
           break;
         }
 
-      // Focuses the previous focusable node
+      // Focuses the previous focusable item
       case key === 'ArrowUp':
         {
-          const previousNode = getPreviousNode(instance, state.focusedNodeId);
-          if (previousNode) {
+          const previousItem = getPreviousItem(instance, itemId);
+          if (previousItem) {
             event.preventDefault();
-            instance.focusItem(event, previousNode);
+            instance.focusItem(event, previousItem);
 
             // Multi select behavior when pressing Shift + ArrowUp
-            // Toggles the selection state of the previous node
-            if (params.multiSelect && event.shiftKey && canToggleNodeSelection(previousNode)) {
+            // Toggles the selection state of the previous item
+            if (params.multiSelect && event.shiftKey && canToggleItemSelection(previousItem)) {
               instance.selectRange(event, {
-                end: previousNode,
-                current: state.focusedNodeId
+                end: previousItem,
+                current: itemId
               }, true);
             }
           }
           break;
         }
 
-      // If the focused node is expanded, we move the focus to its first child
-      // If the focused node is collapsed and has children, we expand it
+      // If the focused item is expanded, we move the focus to its first child
+      // If the focused item is collapsed and has children, we expand it
       case key === 'ArrowRight' && !isRTL || key === 'ArrowLeft' && isRTL:
         {
-          if (instance.isNodeExpanded(state.focusedNodeId)) {
-            instance.focusItem(event, getNextNode(instance, state.focusedNodeId));
-            event.preventDefault();
-          } else if (canToggleNodeExpansion(state.focusedNodeId)) {
-            instance.toggleNodeExpansion(event, state.focusedNodeId);
+          if (instance.isItemExpanded(itemId)) {
+            const nextItemId = getNextItem(instance, itemId);
+            if (nextItemId) {
+              instance.focusItem(event, nextItemId);
+              event.preventDefault();
+            }
+          } else if (canToggleItemExpansion(itemId)) {
+            instance.toggleItemExpansion(event, itemId);
             event.preventDefault();
           }
           break;
         }
 
-      // If the focused node is expanded, we collapse it
-      // If the focused node is collapsed and has a parent, we move the focus to this parent
+      // If the focused item is expanded, we collapse it
+      // If the focused item is collapsed and has a parent, we move the focus to this parent
       case key === 'ArrowLeft' && !isRTL || key === 'ArrowRight' && isRTL:
         {
-          if (canToggleNodeExpansion(state.focusedNodeId) && instance.isNodeExpanded(state.focusedNodeId)) {
-            instance.toggleNodeExpansion(event, state.focusedNodeId);
+          if (canToggleItemExpansion(itemId) && instance.isItemExpanded(itemId)) {
+            instance.toggleItemExpansion(event, itemId);
             event.preventDefault();
           } else {
-            const parent = instance.getNode(state.focusedNodeId).parentId;
+            const parent = instance.getNode(itemId).parentId;
             if (parent) {
               instance.focusItem(event, parent);
               event.preventDefault();
@@ -209,49 +199,49 @@ export const useTreeViewKeyboardNavigation = ({
           break;
         }
 
-      // Focuses the first node in the tree
+      // Focuses the first item in the tree
       case key === 'Home':
         {
-          instance.focusItem(event, getFirstNode(instance));
+          instance.focusItem(event, getFirstItem(instance));
 
           // Multi select behavior when pressing Ctrl + Shift + Home
-          // Selects the focused node and all nodes up to the first node.
-          if (canToggleNodeSelection(state.focusedNodeId) && params.multiSelect && ctrlPressed && event.shiftKey) {
-            instance.rangeSelectToFirst(event, state.focusedNodeId);
+          // Selects the focused item and all items up to the first item.
+          if (canToggleItemSelection(itemId) && params.multiSelect && ctrlPressed && event.shiftKey) {
+            instance.rangeSelectToFirst(event, itemId);
           }
           event.preventDefault();
           break;
         }
 
-      // Focuses the last node in the tree
+      // Focuses the last item in the tree
       case key === 'End':
         {
-          instance.focusItem(event, getLastNode(instance));
+          instance.focusItem(event, getLastItem(instance));
 
           // Multi select behavior when pressing Ctrl + Shirt + End
-          // Selects the focused node and all the nodes down to the last node.
-          if (canToggleNodeSelection(state.focusedNodeId) && params.multiSelect && ctrlPressed && event.shiftKey) {
-            instance.rangeSelectToLast(event, state.focusedNodeId);
+          // 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);
           }
           event.preventDefault();
           break;
         }
 
-      // Expand all siblings that are at the same level as the focused node
+      // Expand all siblings that are at the same level as the focused item
       case key === '*':
         {
-          instance.expandAllSiblings(event, state.focusedNodeId);
+          instance.expandAllSiblings(event, itemId);
           event.preventDefault();
           break;
         }
 
       // Multi select behavior when pressing Ctrl + a
-      // Selects all the nodes
+      // Selects all the items
       case key === 'a' && ctrlPressed && params.multiSelect && !params.disableSelection:
         {
           instance.selectRange(event, {
-            start: getFirstNode(instance),
-            end: getLastNode(instance)
+            start: getFirstItem(instance),
+            end: getLastItem(instance)
           });
           event.preventDefault();
           break;
@@ -261,19 +251,18 @@ export const useTreeViewKeyboardNavigation = ({
       // TODO: Support typing multiple characters
       case !ctrlPressed && !event.shiftKey && isPrintableCharacter(key):
         {
-          const matchingNode = getFirstMatchingNode(state.focusedNodeId, key);
-          if (matchingNode != null) {
-            instance.focusItem(event, matchingNode);
+          const matchingItem = getFirstMatchingItem(itemId, key);
+          if (matchingItem != null) {
+            instance.focusItem(event, matchingItem);
             event.preventDefault();
           }
           break;
         }
     }
   };
-  return {
-    getRootProps: otherHandlers => ({
-      onKeyDown: createHandleKeyDown(otherHandlers)
-    })
-  };
+  populateInstance(instance, {
+    updateFirstCharMap,
+    handleItemKeyDown
+  });
 };
 useTreeViewKeyboardNavigation.params = {};

package/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.types.d.ts

@@ -1,20 +1,23 @@
+import * as React from 'react';
 import { TreeViewPluginSignature } from '../../models';
-import { UseTreeViewNodesSignature } from '../useTreeViewNodes';
+import { UseTreeViewItemsSignature } from '../useTreeViewItems';
 import { UseTreeViewSelectionSignature } from '../useTreeViewSelection';
 import { UseTreeViewFocusSignature } from '../useTreeViewFocus';
 import { UseTreeViewExpansionSignature } from '../useTreeViewExpansion';
+import { MuiCancellableEvent } from '../../models/MuiCancellableEvent';
 export interface UseTreeViewKeyboardNavigationInstance {
     updateFirstCharMap: (updater: (map: TreeViewFirstCharMap) => TreeViewFirstCharMap) => void;
+    handleItemKeyDown: (event: React.KeyboardEvent<HTMLElement> & MuiCancellableEvent, itemId: string) => void;
 }
 export type UseTreeViewKeyboardNavigationSignature = TreeViewPluginSignature<{
     instance: UseTreeViewKeyboardNavigationInstance;
     dependantPlugins: [
-        UseTreeViewNodesSignature,
+        UseTreeViewItemsSignature,
         UseTreeViewSelectionSignature,
         UseTreeViewFocusSignature,
         UseTreeViewExpansionSignature
     ];
 }>;
 export type TreeViewFirstCharMap = {
-    [nodeId: string]: string;
+    [itemId: string]: string;
 };

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -1,19 +1,19 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { populateInstance, getNextNode, getFirstNode, getLastNode } from '../../useTreeView/useTreeView.utils';
+import { populateInstance, getNextItem, getFirstItem, getLastItem } from '../../useTreeView/useTreeView.utils';
 import { findOrderInTremauxTree } from './useTreeViewSelection.utils';
 export const useTreeViewSelection = ({
   instance,
   params,
   models
 }) => {
-  const lastSelectedNode = React.useRef(null);
+  const lastSelectedItem = React.useRef(null);
   const lastSelectionWasRange = React.useRef(false);
   const currentRangeSelection = React.useRef([]);
   const setSelectedItems = (event, newSelectedItems) => {
     if (params.onItemSelectionToggle) {
       if (params.multiSelect) {
-        const addedItems = newSelectedItems.filter(itemId => !instance.isNodeSelected(itemId));
+        const addedItems = newSelectedItems.filter(itemId => !instance.isItemSelected(itemId));
         const removedItems = models.selectedItems.value.filter(itemId => !newSelectedItems.includes(itemId));
         addedItems.forEach(itemId => {
           params.onItemSelectionToggle(event, itemId, true);
@@ -35,46 +35,46 @@ export const useTreeViewSelection = ({
     }
     models.selectedItems.setControlledValue(newSelectedItems);
   };
-  const isNodeSelected = nodeId => Array.isArray(models.selectedItems.value) ? models.selectedItems.value.indexOf(nodeId) !== -1 : models.selectedItems.value === nodeId;
-  const selectNode = (event, nodeId, multiple = false) => {
+  const isItemSelected = itemId => Array.isArray(models.selectedItems.value) ? models.selectedItems.value.indexOf(itemId) !== -1 : models.selectedItems.value === itemId;
+  const selectItem = (event, itemId, multiple = false) => {
     if (params.disableSelection) {
       return;
     }
     if (multiple) {
       if (Array.isArray(models.selectedItems.value)) {
         let newSelected;
-        if (models.selectedItems.value.indexOf(nodeId) !== -1) {
-          newSelected = models.selectedItems.value.filter(id => id !== nodeId);
+        if (models.selectedItems.value.indexOf(itemId) !== -1) {
+          newSelected = models.selectedItems.value.filter(id => id !== itemId);
         } else {
-          newSelected = [nodeId].concat(models.selectedItems.value);
+          newSelected = [itemId].concat(models.selectedItems.value);
         }
         setSelectedItems(event, newSelected);
       }
     } else {
-      const newSelected = params.multiSelect ? [nodeId] : nodeId;
+      const newSelected = params.multiSelect ? [itemId] : itemId;
       setSelectedItems(event, newSelected);
     }
-    lastSelectedNode.current = nodeId;
+    lastSelectedItem.current = itemId;
     lastSelectionWasRange.current = false;
     currentRangeSelection.current = [];
   };
-  const getNodesInRange = (nodeAId, nodeBId) => {
-    const [first, last] = findOrderInTremauxTree(instance, nodeAId, nodeBId);
-    const nodes = [first];
+  const getItemsInRange = (itemAId, itemBId) => {
+    const [first, last] = findOrderInTremauxTree(instance, itemAId, itemBId);
+    const items = [first];
     let current = first;
     while (current !== last) {
-      current = getNextNode(instance, current);
-      nodes.push(current);
+      current = getNextItem(instance, current);
+      items.push(current);
     }
-    return nodes;
+    return items;
   };
-  const handleRangeArrowSelect = (event, nodes) => {
+  const handleRangeArrowSelect = (event, items) => {
     let base = models.selectedItems.value.slice();
     const {
       start,
       next,
       current
-    } = nodes;
+    } = items;
     if (!next || !current) {
       return;
     }
@@ -95,32 +95,32 @@ export const useTreeViewSelection = ({
     }
     setSelectedItems(event, base);
   };
-  const handleRangeSelect = (event, nodes) => {
+  const handleRangeSelect = (event, items) => {
     let base = models.selectedItems.value.slice();
     const {
       start,
       end
-    } = nodes;
-    // If last selection was a range selection ignore nodes that were selected.
+    } = 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);
     }
-    let range = getNodesInRange(start, end);
-    range = range.filter(node => !instance.isNodeDisabled(node));
+    let range = getItemsInRange(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, nodes, stacked = false) => {
+  const selectRange = (event, items, stacked = false) => {
     if (params.disableSelection) {
       return;
     }
     const {
-      start = lastSelectedNode.current,
+      start = lastSelectedItem.current,
       end,
       current
-    } = nodes;
+    } = items;
     if (stacked) {
       handleRangeArrowSelect(event, {
         start,
@@ -135,29 +135,29 @@ export const useTreeViewSelection = ({
     }
     lastSelectionWasRange.current = true;
   };
-  const rangeSelectToFirst = (event, nodeId) => {
-    if (!lastSelectedNode.current) {
-      lastSelectedNode.current = nodeId;
+  const rangeSelectToFirst = (event, itemId) => {
+    if (!lastSelectedItem.current) {
+      lastSelectedItem.current = itemId;
     }
-    const start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;
+    const start = lastSelectionWasRange.current ? lastSelectedItem.current : itemId;
     instance.selectRange(event, {
       start,
-      end: getFirstNode(instance)
+      end: getFirstItem(instance)
     });
   };
-  const rangeSelectToLast = (event, nodeId) => {
-    if (!lastSelectedNode.current) {
-      lastSelectedNode.current = nodeId;
+  const rangeSelectToLast = (event, itemId) => {
+    if (!lastSelectedItem.current) {
+      lastSelectedItem.current = itemId;
     }
-    const start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;
+    const start = lastSelectionWasRange.current ? lastSelectedItem.current : itemId;
     instance.selectRange(event, {
       start,
-      end: getLastNode(instance)
+      end: getLastItem(instance)
     });
   };
   populateInstance(instance, {
-    isNodeSelected,
-    selectNode,
+    isItemSelected,
+    selectItem,
     selectRange,
     rangeSelectToLast,
     rangeSelectToFirst
@@ -178,15 +178,12 @@ useTreeViewSelection.models = {
     getDefaultValue: params => params.defaultSelectedItems
   }
 };
-const DEFAULT_SELECTED_NODES = [];
-useTreeViewSelection.getDefaultizedParams = params => {
-  var _params$disableSelect, _params$multiSelect, _params$defaultSelect;
-  return _extends({}, params, {
-    disableSelection: (_params$disableSelect = params.disableSelection) != null ? _params$disableSelect : false,
-    multiSelect: (_params$multiSelect = params.multiSelect) != null ? _params$multiSelect : false,
-    defaultSelectedItems: (_params$defaultSelect = params.defaultSelectedItems) != null ? _params$defaultSelect : params.multiSelect ? DEFAULT_SELECTED_NODES : null
-  });
-};
+const DEFAULT_SELECTED_ITEMS = [];
+useTreeViewSelection.getDefaultizedParams = params => _extends({}, params, {
+  disableSelection: params.disableSelection ?? false,
+  multiSelect: params.multiSelect ?? false,
+  defaultSelectedItems: params.defaultSelectedItems ?? (params.multiSelect ? DEFAULT_SELECTED_ITEMS : null)
+});
 useTreeViewSelection.params = {
   disableSelection: true,
   multiSelect: true,

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.types.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
 import type { DefaultizedProps, TreeViewItemRange, TreeViewPluginSignature } from '../../models';
-import { UseTreeViewNodesSignature } from '../useTreeViewNodes';
+import { UseTreeViewItemsSignature } from '../useTreeViewItems';
 import { UseTreeViewExpansionSignature } from '../useTreeViewExpansion';
 export interface UseTreeViewSelectionInstance {
-    isNodeSelected: (nodeId: string) => boolean;
-    selectNode: (event: React.SyntheticEvent, nodeId: string, multiple?: boolean) => void;
-    selectRange: (event: React.SyntheticEvent, nodes: TreeViewItemRange, stacked?: boolean) => void;
-    rangeSelectToFirst: (event: React.KeyboardEvent<HTMLUListElement>, nodeId: string) => void;
-    rangeSelectToLast: (event: React.KeyboardEvent<HTMLUListElement>, nodeId: string) => void;
+    isItemSelected: (itemId: string) => boolean;
+    selectItem: (event: React.SyntheticEvent, itemId: string, multiple?: boolean) => void;
+    selectRange: (event: React.SyntheticEvent, items: TreeViewItemRange, stacked?: boolean) => void;
+    rangeSelectToFirst: (event: React.KeyboardEvent, itemId: string) => void;
+    rangeSelectToLast: (event: React.KeyboardEvent, itemId: string) => void;
 }
 type TreeViewSelectionValue<Multiple extends boolean | undefined> = Multiple extends true ? string[] : string | null;
 export interface UseTreeViewSelectionParameters<Multiple extends boolean | undefined> {
@@ -58,9 +58,9 @@ export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
     contextValue: UseTreeViewSelectionContextValue;
     modelNames: 'selectedItems';
     dependantPlugins: [
-        UseTreeViewNodesSignature,
+        UseTreeViewItemsSignature,
         UseTreeViewExpansionSignature,
-        UseTreeViewNodesSignature
+        UseTreeViewItemsSignature
     ];
 }>;
 export {};

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.utils.d.ts

@@ -1,17 +1,17 @@
 import { TreeViewInstance } from '../../models';
-import { UseTreeViewNodesSignature } from '../useTreeViewNodes';
+import { UseTreeViewItemsSignature } from '../useTreeViewItems';
 /**
  * This is used to determine the start and end of a selection range so
- * we can get the nodes between the two border nodes.
+ * we can get the items between the two border items.
  *
- * It finds the nodes' common ancestor using
+ * 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 nodeA and NodeB
- * so we can compare their indexes to work out which node comes first in a depth first search.
+ * 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 node is shallower in a trémaux tree
+ * 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<[UseTreeViewNodesSignature]>, nodeAId: string, nodeBId: string) => string[];
+export declare const findOrderInTremauxTree: (instance: TreeViewInstance<[UseTreeViewItemsSignature]>, nodeAId: string, nodeBId: string) => string[];

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

@@ -1,15 +1,15 @@
 /**
  * This is used to determine the start and end of a selection range so
- * we can get the nodes between the two border nodes.
+ * we can get the items between the two border items.
  *
- * It finds the nodes' common ancestor using
+ * 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 nodeA and NodeB
- * so we can compare their indexes to work out which node comes first in a depth first search.
+ * 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 node is shallower in a trémaux tree
+ * 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 const findOrderInTremauxTree = (instance, nodeAId, nodeBId) => {