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

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

@@ -15,8 +15,7 @@ function findNextFirstChar(firstChars, startIndex, char) {
 }
 export const useTreeViewKeyboardNavigation = ({
   instance,
-  params,
-  state
+  params
 }) => {
   const theme = useTheme();
   const isRTL = theme.direction === 'rtl';
@@ -33,35 +32,32 @@ export const useTreeViewKeyboardNavigation = ({
     const newFirstCharMap = {};
     const processItem = item => {
       const getItemId = params.getItemId;
-      const nodeId = getItemId ? getItemId(item) : item.id;
-      newFirstCharMap[nodeId] = instance.getNode(nodeId).label.substring(0, 1).toLowerCase();
+      const itemId = getItemId ? getItemId(item) : item.id;
+      newFirstCharMap[itemId] = instance.getNode(itemId).label.substring(0, 1).toLowerCase();
       item.children?.forEach(processItem);
     };
     params.items.forEach(processItem);
     firstCharMap.current = newFirstCharMap;
   }, [params.items, params.getItemId, instance]);
-  populateInstance(instance, {
-    updateFirstCharMap
-  });
-  const getFirstMatchingNode = (nodeId, firstChar) => {
+  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);
+    Object.keys(firstCharMap.current).forEach(mapItemId => {
+      const map = instance.getNode(mapItemId);
       const visible = map.parentId ? instance.isNodeExpanded(map.parentId) : true;
-      const shouldBeSkipped = params.disabledItemsFocusable ? false : instance.isNodeDisabled(mapNodeId);
+      const shouldBeSkipped = params.disabledItemsFocusable ? false : instance.isNodeDisabled(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;
     }
@@ -80,20 +76,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.isNodeDisabled(itemId);
+  const canToggleItemExpansion = itemId => {
+    return !instance.isNodeDisabled(itemId) && instance.isNodeExpandable(itemId);
   };
 
   // ARIA specification: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/#keyboardinteraction
-  const createHandleKeyDown = otherHandlers => event => {
-    otherHandlers.onKeyDown?.(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;
@@ -102,17 +95,17 @@ export const useTreeViewKeyboardNavigation = ({
     // eslint-disable-next-line default-case
     switch (true) {
       // Select the node when pressing "Space"
-      case key === ' ' && canToggleNodeSelection(state.focusedNodeId):
+      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.selectNode(event, itemId, true);
           } else {
-            instance.selectNode(event, state.focusedNodeId);
+            instance.selectNode(event, itemId);
           }
           break;
         }
@@ -121,84 +114,87 @@ export const useTreeViewKeyboardNavigation = ({
       // If the focused node has no children, we select it.
       case key === 'Enter':
         {
-          if (canToggleNodeExpansion(state.focusedNodeId)) {
-            instance.toggleNodeExpansion(event, state.focusedNodeId);
+          if (canToggleItemExpansion(itemId)) {
+            instance.toggleNodeExpansion(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.selectNode(event, itemId, true);
+            } else if (!instance.isNodeSelected(itemId)) {
+              instance.selectNode(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 = getNextNode(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 = getPreviousNode(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.isNodeExpanded(itemId)) {
+            const nextNodeId = getNextNode(instance, itemId);
+            if (nextNodeId) {
+              instance.focusItem(event, nextNodeId);
+              event.preventDefault();
+            }
+          } else if (canToggleItemExpansion(itemId)) {
+            instance.toggleNodeExpansion(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.isNodeExpanded(itemId)) {
+            instance.toggleNodeExpansion(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();
@@ -214,31 +210,31 @@ export const useTreeViewKeyboardNavigation = ({
 
           // 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);
+          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));
 
           // 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;
         }
@@ -259,7 +255,7 @@ export const useTreeViewKeyboardNavigation = ({
       // TODO: Support typing multiple characters
       case !ctrlPressed && !event.shiftKey && isPrintableCharacter(key):
         {
-          const matchingNode = getFirstMatchingNode(state.focusedNodeId, key);
+          const matchingNode = getFirstMatchingItem(itemId, key);
           if (matchingNode != null) {
             instance.focusItem(event, matchingNode);
             event.preventDefault();
@@ -268,10 +264,9 @@ export const useTreeViewKeyboardNavigation = ({
         }
     }
   };
-  return {
-    getRootProps: otherHandlers => ({
-      onKeyDown: createHandleKeyDown(otherHandlers)
-    })
-  };
+  populateInstance(instance, {
+    updateFirstCharMap,
+    handleItemKeyDown
+  });
 };
 useTreeViewKeyboardNavigation.params = {};

package/modern/internals/plugins/useTreeViewNodes/useTreeViewNodes.js

@@ -1,6 +1,5 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import useEventCallback from '@mui/utils/useEventCallback';
 import { populateInstance, populatePublicAPI } from '../../useTreeView/useTreeView.utils';
 import { publishTreeViewEvent } from '../../utils/publishTreeViewEvent';
 const updateNodesState = ({
@@ -52,34 +51,34 @@ export const useTreeViewNodes = ({
   state,
   setState
 }) => {
-  const getNode = React.useCallback(nodeId => state.nodes.nodeMap[nodeId], [state.nodes.nodeMap]);
-  const getItem = React.useCallback(nodeId => state.nodes.itemMap[nodeId], [state.nodes.itemMap]);
-  const isNodeDisabled = React.useCallback(nodeId => {
-    if (nodeId == null) {
+  const getNode = React.useCallback(itemId => state.nodes.nodeMap[itemId], [state.nodes.nodeMap]);
+  const getItem = React.useCallback(itemId => state.nodes.itemMap[itemId], [state.nodes.itemMap]);
+  const isNodeDisabled = React.useCallback(itemId => {
+    if (itemId == null) {
       return false;
     }
-    let node = instance.getNode(nodeId);
+    let item = instance.getNode(itemId);
 
-    // This can be called before the node has been added to the node map.
-    if (!node) {
+    // This can be called before the item has been added to the node map.
+    if (!item) {
       return false;
     }
-    if (node.disabled) {
+    if (item.disabled) {
       return true;
     }
-    while (node.parentId != null) {
-      node = instance.getNode(node.parentId);
-      if (node.disabled) {
+    while (item.parentId != null) {
+      item = instance.getNode(item.parentId);
+      if (item.disabled) {
         return true;
       }
     }
     return false;
   }, [instance]);
-  const getChildrenIds = useEventCallback(nodeId => Object.values(state.nodes.nodeMap).filter(node => node.parentId === nodeId).sort((a, b) => a.index - b.index).map(child => child.id));
-  const getNavigableChildrenIds = nodeId => {
-    let childrenIds = instance.getChildrenIds(nodeId);
+  const getChildrenIds = React.useCallback(itemId => Object.values(state.nodes.nodeMap).filter(item => item.parentId === itemId).sort((a, b) => a.index - b.index).map(child => child.id), [state.nodes.nodeMap]);
+  const getNavigableChildrenIds = itemId => {
+    let childrenIds = instance.getChildrenIds(itemId);
     if (!params.disabledItemsFocusable) {
-      childrenIds = childrenIds.filter(node => !instance.isNodeDisabled(node));
+      childrenIds = childrenIds.filter(item => !instance.isNodeDisabled(item));
     }
     return childrenIds;
   };
@@ -104,19 +103,19 @@ export const useTreeViewNodes = ({
     });
   }, [instance, setState, params.items, params.isItemDisabled, params.getItemId, params.getItemLabel]);
   const getNodesToRender = () => {
-    const getPropsFromNodeId = ({
+    const getPropsFromItemId = ({
       id,
       children
     }) => {
       const node = state.nodes.nodeMap[id];
       return {
         label: node.label,
-        nodeId: node.id,
+        itemId: node.id,
         id: node.idAttribute,
-        children: children?.map(getPropsFromNodeId)
+        children: children?.map(getPropsFromItemId)
       };
     };
-    return state.nodes.nodeTree.map(getPropsFromNodeId);
+    return state.nodes.nodeTree.map(getPropsFromItemId);
   };
   populateInstance(instance, {
     getNode,

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

@@ -35,26 +35,26 @@ 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 isNodeSelected = itemId => Array.isArray(models.selectedItems.value) ? models.selectedItems.value.indexOf(itemId) !== -1 : models.selectedItems.value === itemId;
+  const selectNode = (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;
+    lastSelectedNode.current = itemId;
     lastSelectionWasRange.current = false;
     currentRangeSelection.current = [];
   };
@@ -135,21 +135,21 @@ export const useTreeViewSelection = ({
     }
     lastSelectionWasRange.current = true;
   };
-  const rangeSelectToFirst = (event, nodeId) => {
+  const rangeSelectToFirst = (event, itemId) => {
     if (!lastSelectedNode.current) {
-      lastSelectedNode.current = nodeId;
+      lastSelectedNode.current = itemId;
     }
-    const start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;
+    const start = lastSelectionWasRange.current ? lastSelectedNode.current : itemId;
     instance.selectRange(event, {
       start,
       end: getFirstNode(instance)
     });
   };
-  const rangeSelectToLast = (event, nodeId) => {
+  const rangeSelectToLast = (event, itemId) => {
     if (!lastSelectedNode.current) {
-      lastSelectedNode.current = nodeId;
+      lastSelectedNode.current = itemId;
     }
-    const start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;
+    const start = lastSelectionWasRange.current ? lastSelectedNode.current : itemId;
     instance.selectRange(event, {
       start,
       end: getLastNode(instance)

package/modern/internals/useTreeView/useTreeView.js

@@ -87,13 +87,13 @@ export const useTreeView = inParams => {
   };
   const itemWrappers = plugins.map(plugin => plugin.wrapItem).filter(wrapItem => !!wrapItem);
   contextValue.wrapItem = ({
-    nodeId,
+    itemId,
     children
   }) => {
     let finalChildren = children;
     itemWrappers.forEach(itemWrapper => {
       finalChildren = itemWrapper({
-        nodeId,
+        itemId,
         children: finalChildren
       });
     });
@@ -101,8 +101,7 @@ export const useTreeView = inParams => {
   };
   const getRootProps = (otherHandlers = {}) => {
     const rootProps = _extends({
-      role: 'tree',
-      tabIndex: 0
+      role: 'tree'
     }, otherHandlers, {
       ref: handleRootRef
     });

package/modern/internals/useTreeView/useTreeView.utils.js

@@ -1,41 +1,41 @@
-export const getPreviousNode = (instance, nodeId) => {
-  const node = instance.getNode(nodeId);
-  const siblings = instance.getNavigableChildrenIds(node.parentId);
-  const nodeIndex = siblings.indexOf(nodeId);
-  if (nodeIndex === 0) {
-    return node.parentId;
+export const getPreviousNode = (instance, itemId) => {
+  const item = instance.getNode(itemId);
+  const siblings = instance.getNavigableChildrenIds(item.parentId);
+  const itemIndex = siblings.indexOf(itemId);
+  if (itemIndex === 0) {
+    return item.parentId;
   }
-  let currentNode = siblings[nodeIndex - 1];
-  while (instance.isNodeExpanded(currentNode) && instance.getNavigableChildrenIds(currentNode).length > 0) {
-    currentNode = instance.getNavigableChildrenIds(currentNode).pop();
+  let currentItem = siblings[itemIndex - 1];
+  while (instance.isNodeExpanded(currentItem) && instance.getNavigableChildrenIds(currentItem).length > 0) {
+    currentItem = instance.getNavigableChildrenIds(currentItem).pop();
   }
-  return currentNode;
+  return currentItem;
 };
-export const getNextNode = (instance, nodeId) => {
+export const getNextNode = (instance, itemId) => {
   // If expanded get first child
-  if (instance.isNodeExpanded(nodeId) && instance.getNavigableChildrenIds(nodeId).length > 0) {
-    return instance.getNavigableChildrenIds(nodeId)[0];
+  if (instance.isNodeExpanded(itemId) && instance.getNavigableChildrenIds(itemId).length > 0) {
+    return instance.getNavigableChildrenIds(itemId)[0];
   }
-  let node = instance.getNode(nodeId);
-  while (node != null) {
+  let item = instance.getNode(itemId);
+  while (item != null) {
     // Try to get next sibling
-    const siblings = instance.getNavigableChildrenIds(node.parentId);
-    const nextSibling = siblings[siblings.indexOf(node.id) + 1];
+    const siblings = instance.getNavigableChildrenIds(item.parentId);
+    const nextSibling = siblings[siblings.indexOf(item.id) + 1];
     if (nextSibling) {
       return nextSibling;
     }
 
     // If the sibling does not exist, go up a level to the parent and try again.
-    node = instance.getNode(node.parentId);
+    item = instance.getNode(item.parentId);
   }
   return null;
 };
 export const getLastNode = instance => {
-  let lastNode = instance.getNavigableChildrenIds(null).pop();
-  while (instance.isNodeExpanded(lastNode)) {
-    lastNode = instance.getNavigableChildrenIds(lastNode).pop();
+  let lastItem = instance.getNavigableChildrenIds(null).pop();
+  while (instance.isNodeExpanded(lastItem)) {
+    lastItem = instance.getNavigableChildrenIds(lastItem).pop();
   }
-  return lastNode;
+  return lastItem;
 };
 export const getFirstNode = instance => instance.getNavigableChildrenIds(null)[0];
 export const populateInstance = (instance, methods) => {

package/modern/internals/utils/utils.js

@@ -1,3 +1,4 @@
+// https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
 export const getActiveElement = (root = document) => {
   const activeEl = root.activeElement;
   if (!activeEl) {

package/modern/useTreeItem2/useTreeItem2.js

@@ -15,7 +15,7 @@ export const useTreeItem2 = parameters => {
   } = useTreeViewContext();
   const {
     id,
-    nodeId,
+    itemId,
     label,
     children,
     rootRef
@@ -28,25 +28,34 @@ export const useTreeItem2 = parameters => {
     interactions,
     status
   } = useTreeItem2Utils({
-    nodeId,
+    itemId,
     children
   });
-  const idAttribute = instance.getTreeItemId(nodeId, id);
+  const idAttribute = instance.getTreeItemId(itemId, id);
   const handleRootRef = useForkRef(rootRef, pluginRootRef);
   const createRootHandleFocus = otherHandlers => event => {
     otherHandlers.onFocus?.(event);
     if (event.defaultMuiPrevented) {
       return;
     }
-
-    // DOM focus stays on the tree which manages focus with aria-activedescendant
-    if (event.target === event.currentTarget) {
-      instance.focusRoot();
-    }
     const canBeFocused = !status.disabled || disabledItemsFocusable;
     if (!status.focused && canBeFocused && event.currentTarget === event.target) {
-      instance.focusItem(event, nodeId);
+      instance.focusItem(event, itemId);
+    }
+  };
+  const createRootHandleBlur = otherHandlers => event => {
+    otherHandlers.onBlur?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    instance.removeFocusedItem();
+  };
+  const createRootHandleKeyDown = otherHandlers => event => {
+    otherHandlers.onKeyDown?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
     }
+    instance.handleItemKeyDown(event, itemId);
   };
   const createContentHandleClick = otherHandlers => event => {
     otherHandlers.onClick?.(event);
@@ -76,7 +85,7 @@ export const useTreeItem2 = parameters => {
       /* single-selection trees unset aria-selected on un-selected items.
        *
        * If the tree does not support multiple selection, aria-selected
-       * is set to true for the selected node and it is not present on any other node in the tree.
+       * is set to true for the selected item and it is not present on any other item in the tree.
        * Source: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/
        */
       ariaSelected = true;
@@ -84,13 +93,15 @@ export const useTreeItem2 = parameters => {
     return _extends({}, externalEventHandlers, {
       ref: handleRootRef,
       role: 'treeitem',
-      tabIndex: -1,
+      tabIndex: instance.canItemBeTabbed(itemId) ? 0 : -1,
       id: idAttribute,
       'aria-expanded': status.expandable ? status.expanded : undefined,
       'aria-selected': ariaSelected,
       'aria-disabled': status.disabled || undefined
     }, externalProps, {
-      onFocus: createRootHandleFocus(externalEventHandlers)
+      onFocus: createRootHandleFocus(externalEventHandlers),
+      onBlur: createRootHandleBlur(externalEventHandlers),
+      onKeyDown: createRootHandleKeyDown(externalEventHandlers)
     });
   };
   const getContentProps = (externalProps = {}) => {

package/node/RichTreeView/RichTreeView.js

@@ -45,7 +45,7 @@ function WrappedTreeItem({
   slotProps,
   label,
   id,
-  nodeId,
+  itemId,
   children
 }) {
   const Item = slots?.item ?? _TreeItem.TreeItem;
@@ -53,12 +53,12 @@ function WrappedTreeItem({
     elementType: Item,
     externalSlotProps: slotProps?.item,
     additionalProps: {
-      nodeId,
+      itemId,
       id,
       label
     },
     ownerState: {
-      nodeId,
+      itemId,
       label
     }
   });
@@ -66,7 +66,7 @@ function WrappedTreeItem({
     children: children
   }));
 }
-const childrenWarning = (0, _warning.buildWarning)(['MUI X: The `RichTreeView` component does not support JSX children.', 'If you want to add items, you need to use the `items` prop', 'Check the documentation for more details: https://next.mui.com/x/react-tree-view/rich-tree-view/items/']);
+const childrenWarning = (0, _warning.buildWarning)(['MUI X: The `RichTreeView` component does not support JSX children.', 'If you want to add items, you need to use the `items` prop', 'Check the documentation for more details: https://mui.com/x/react-tree-view/rich-tree-view/items/']);
 
 /**
  *
@@ -116,7 +116,7 @@ const RichTreeView = exports.RichTreeView = /*#__PURE__*/React.forwardRef(functi
   const nodesToRender = instance.getNodesToRender();
   const renderNode = ({
     label,
-    nodeId,
+    itemId,
     id,
     children
   }) => {
@@ -125,9 +125,9 @@ const RichTreeView = exports.RichTreeView = /*#__PURE__*/React.forwardRef(functi
       slotProps: slotProps,
       label: label,
       id: id,
-      nodeId: nodeId,
+      itemId: itemId,
       children: children?.map(renderNode)
-    }, nodeId);
+    }, itemId);
   };
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(_TreeViewProvider.TreeViewProvider, {
     value: contextValue,