@mui/x-tree-view 7.0.0-alpha.7 → 7.0.0-alpha.8

package/modern/RichTreeView/RichTreeView.js

@@ -1,6 +1,6 @@
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _extends from "@babel/runtime/helpers/esm/extends";
-const _excluded = ["disabledItemsFocusable", "expandedNodes", "defaultExpandedNodes", "onExpandedNodesChange", "onNodeExpansionToggle", "onNodeFocus", "disableSelection", "defaultSelectedNodes", "selectedNodes", "multiSelect", "onSelectedNodesChange", "onNodeSelectionToggle", "id", "defaultCollapseIcon", "defaultEndIcon", "defaultExpandIcon", "defaultParentIcon", "items", "getItemId", "getItemLabel", "isItemDisabled", "slots", "slotProps"];
+const _excluded = ["slots", "slotProps"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { styled, useThemeProps } from '@mui/material/styles';
@@ -12,6 +12,7 @@ import { TreeViewProvider } from '../internals/TreeViewProvider';
 import { DEFAULT_TREE_VIEW_PLUGINS } from '../internals/plugins';
 import { TreeItem } from '../TreeItem';
 import { buildWarning } from '../internals/utils/warning';
+import { extractPluginParamsFromProps } from '../internals/utils/extractPluginParamsFromProps';
 import { jsx as _jsx } from "react/jsx-runtime";
 const useUtilityClasses = ownerState => {
   const {
@@ -58,7 +59,7 @@ function WrappedTreeItem({
     children: children
   }));
 }
-const childrenWarning = buildWarning(['MUI: 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 = 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/']);
 
 /**
  *
@@ -75,75 +76,35 @@ const RichTreeView = /*#__PURE__*/React.forwardRef(function RichTreeView(inProps
     props: inProps,
     name: 'MuiRichTreeView'
   });
-  const _ref = props,
-    {
-      // Headless implementation
-      disabledItemsFocusable,
-      expandedNodes,
-      defaultExpandedNodes,
-      onExpandedNodesChange,
-      onNodeExpansionToggle,
-      onNodeFocus,
-      disableSelection,
-      defaultSelectedNodes,
-      selectedNodes,
-      multiSelect,
-      onSelectedNodesChange,
-      onNodeSelectionToggle,
-      id: treeId,
-      defaultCollapseIcon,
-      defaultEndIcon,
-      defaultExpandIcon,
-      defaultParentIcon,
-      items,
-      getItemId,
-      getItemLabel,
-      isItemDisabled,
-      // Component implementation
-      slots,
-      slotProps
-    } = _ref,
-    other = _objectWithoutPropertiesLoose(_ref, _excluded);
   if (process.env.NODE_ENV !== 'production') {
     if (props.children != null) {
       childrenWarning();
     }
   }
+  const _extractPluginParamsF = extractPluginParamsFromProps({
+      props,
+      plugins: DEFAULT_TREE_VIEW_PLUGINS,
+      rootRef: ref
+    }),
+    {
+      pluginParams,
+      otherProps: {
+        slots,
+        slotProps
+      }
+    } = _extractPluginParamsF,
+    otherProps = _objectWithoutPropertiesLoose(_extractPluginParamsF.otherProps, _excluded);
   const {
     getRootProps,
     contextValue,
     instance
-  } = useTreeView({
-    disabledItemsFocusable,
-    expandedNodes,
-    defaultExpandedNodes,
-    onExpandedNodesChange,
-    onNodeExpansionToggle,
-    onNodeFocus,
-    disableSelection,
-    defaultSelectedNodes,
-    selectedNodes,
-    multiSelect,
-    onSelectedNodesChange,
-    onNodeSelectionToggle,
-    id: treeId,
-    defaultCollapseIcon,
-    defaultEndIcon,
-    defaultExpandIcon,
-    defaultParentIcon,
-    items,
-    getItemId,
-    getItemLabel,
-    isItemDisabled,
-    plugins: DEFAULT_TREE_VIEW_PLUGINS,
-    rootRef: ref
-  });
+  } = useTreeView(pluginParams);
   const classes = useUtilityClasses(props);
   const Root = slots?.root ?? RichTreeViewRoot;
   const rootProps = useSlotProps({
     elementType: Root,
     externalSlotProps: slotProps?.root,
-    externalForwardedProps: other,
+    externalForwardedProps: otherProps,
     className: classes.root,
     getSlotProps: getRootProps,
     ownerState: props

package/modern/SimpleTreeView/SimpleTreeView.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["disabledItemsFocusable", "expandedNodes", "defaultExpandedNodes", "onExpandedNodesChange", "onNodeExpansionToggle", "onNodeFocus", "disableSelection", "defaultSelectedNodes", "selectedNodes", "multiSelect", "onSelectedNodesChange", "onNodeSelectionToggle", "id", "defaultCollapseIcon", "defaultEndIcon", "defaultExpandIcon", "defaultParentIcon", "children", "slots", "slotProps"];
+const _excluded = ["slots", "slotProps"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { styled, useThemeProps } from '@mui/material/styles';
@@ -11,6 +11,7 @@ import { useTreeView } from '../internals/useTreeView';
 import { TreeViewProvider } from '../internals/TreeViewProvider';
 import { SIMPLE_TREE_VIEW_PLUGINS } from './SimpleTreeView.plugins';
 import { buildWarning } from '../internals/utils/warning';
+import { extractPluginParamsFromProps } from '../internals/utils/extractPluginParamsFromProps';
 import { jsx as _jsx } from "react/jsx-runtime";
 const useUtilityClasses = ownerState => {
   const {
@@ -32,7 +33,7 @@ export const SimpleTreeViewRoot = styled('ul', {
   outline: 0
 });
 const EMPTY_ITEMS = [];
-const itemsPropWarning = buildWarning(['MUI: The `SimpleTreeView` component does not support the `items` prop.', 'If you want to add items, you need to pass them as JSX children.', 'Check the documentation for more details: https://next.mui.com/x/react-tree-view/simple-tree-view/items/']);
+const itemsPropWarning = buildWarning(['MUI X: The `SimpleTreeView` component does not support the `items` prop.', 'If you want to add items, you need to pass them as JSX children.', 'Check the documentation for more details: https://next.mui.com/x/react-tree-view/simple-tree-view/items/']);
 
 /**
  *
@@ -50,76 +51,42 @@ const SimpleTreeView = /*#__PURE__*/React.forwardRef(function SimpleTreeView(inP
     name: 'MuiSimpleTreeView'
   });
   const ownerState = props;
-  const _ref = props,
-    {
-      // Headless implementation
-      disabledItemsFocusable,
-      expandedNodes,
-      defaultExpandedNodes,
-      onExpandedNodesChange,
-      onNodeExpansionToggle,
-      onNodeFocus,
-      disableSelection,
-      defaultSelectedNodes,
-      selectedNodes,
-      multiSelect,
-      onSelectedNodesChange,
-      onNodeSelectionToggle,
-      id,
-      defaultCollapseIcon,
-      defaultEndIcon,
-      defaultExpandIcon,
-      defaultParentIcon,
-      // Component implementation
-      children,
-      slots
-    } = _ref,
-    other = _objectWithoutPropertiesLoose(_ref, _excluded);
   if (process.env.NODE_ENV !== 'production') {
     if (props.items != null) {
       itemsPropWarning();
     }
   }
+  const _extractPluginParamsF = extractPluginParamsFromProps({
+      props: _extends({}, props, {
+        items: EMPTY_ITEMS
+      }),
+      plugins: SIMPLE_TREE_VIEW_PLUGINS,
+      rootRef: ref
+    }),
+    {
+      pluginParams,
+      otherProps: {
+        slots
+      }
+    } = _extractPluginParamsF,
+    otherProps = _objectWithoutPropertiesLoose(_extractPluginParamsF.otherProps, _excluded);
   const {
     getRootProps,
     contextValue
-  } = useTreeView({
-    disabledItemsFocusable,
-    expandedNodes,
-    defaultExpandedNodes,
-    onExpandedNodesChange,
-    onNodeExpansionToggle,
-    onNodeFocus,
-    disableSelection,
-    defaultSelectedNodes,
-    selectedNodes,
-    multiSelect,
-    onSelectedNodesChange,
-    onNodeSelectionToggle,
-    id,
-    defaultCollapseIcon,
-    defaultEndIcon,
-    defaultExpandIcon,
-    defaultParentIcon,
-    items: EMPTY_ITEMS,
-    plugins: SIMPLE_TREE_VIEW_PLUGINS,
-    rootRef: ref
-  });
+  } = useTreeView(pluginParams);
   const classes = useUtilityClasses(props);
   const Root = slots?.root ?? SimpleTreeViewRoot;
   const rootProps = useSlotProps({
     elementType: Root,
     externalSlotProps: {},
-    externalForwardedProps: other,
+    externalForwardedProps: otherProps,
     className: classes.root,
     getSlotProps: getRootProps,
     ownerState
   });
   return /*#__PURE__*/_jsx(TreeViewProvider, {
     value: contextValue,
-    children: /*#__PURE__*/_jsx(Root, _extends({}, rootProps, {
-      children: children
-    }))
+    children: /*#__PURE__*/_jsx(Root, _extends({}, rootProps))
   });
 });
 process.env.NODE_ENV !== "production" ? SimpleTreeView.propTypes = {

package/modern/TreeView/TreeView.js

@@ -23,7 +23,7 @@ const TreeViewRoot = styled(SimpleTreeViewRoot, {
 let warnedOnce = false;
 const warn = () => {
   if (!warnedOnce) {
-    console.warn(['MUI: The TreeView component was renamed SimpleTreeView.', 'The component with the old naming will be removed in the version v8.0.0.', '', "You should use `import { SimpleTreeView } from '@mui/x-tree-view'`", "or `import { SimpleTreeView } from '@mui/x-tree-view/TreeView'`"].join('\n'));
+    console.warn(['MUI X: The TreeView component was renamed SimpleTreeView.', 'The component with the old naming will be removed in the version v8.0.0.', '', "You should use `import { SimpleTreeView } from '@mui/x-tree-view'`", "or `import { SimpleTreeView } from '@mui/x-tree-view/TreeView'`"].join('\n'));
     warnedOnce = true;
   }
 };

package/modern/index.js

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

package/modern/internals/TreeViewProvider/useTreeViewContext.js

@@ -3,7 +3,7 @@ import { TreeViewContext } from './TreeViewContext';
 export const useTreeViewContext = () => {
   const context = React.useContext(TreeViewContext);
   if (context == null) {
-    throw new Error(['MUI: Could not find the Tree View context.', 'It looks like you rendered your component outside of a SimpleTreeView or RichTreeView parent component.', 'This can also happen if you are bundling multiple versions of the Tree View.'].join('\n'));
+    throw new Error(['MUI X: Could not find the Tree View context.', 'It looks like you rendered your component outside of a SimpleTreeView or RichTreeView parent component.', 'This can also happen if you are bundling multiple versions of the Tree View.'].join('\n'));
   }
   return context;
 };

package/modern/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.js

@@ -26,4 +26,5 @@ export const useTreeViewInstanceEvents = ({
     $$publishEvent: publishEvent,
     $$subscribeEvent: subscribeEvent
   });
-};
+};
+useTreeViewInstanceEvents.params = {};

package/modern/internals/models/MuiCancellableEvent.js

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

package/modern/internals/plugins/useTreeViewContextValueBuilder/useTreeViewContextValueBuilder.js

@@ -23,4 +23,10 @@ export const useTreeViewContextValueBuilder = ({
       }
     }
   };
+};
+useTreeViewContextValueBuilder.params = {
+  defaultCollapseIcon: true,
+  defaultEndIcon: true,
+  defaultExpandIcon: true,
+  defaultParentIcon: true
 };

package/modern/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -63,4 +63,10 @@ useTreeViewExpansion.models = {
 const DEFAULT_EXPANDED_NODES = [];
 useTreeViewExpansion.getDefaultizedParams = params => _extends({}, params, {
   defaultExpandedNodes: params.defaultExpandedNodes ?? DEFAULT_EXPANDED_NODES
-});
+});
+useTreeViewExpansion.params = {
+  expandedNodes: true,
+  defaultExpandedNodes: true,
+  onExpandedNodesChange: true,
+  onNodeExpansionToggle: true
+};

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

@@ -87,4 +87,7 @@ useTreeViewFocus.getInitialState = () => ({
 });
 useTreeViewFocus.getDefaultizedParams = params => _extends({}, params, {
   disabledItemsFocusable: params.disabledItemsFocusable ?? false
-});
+});
+useTreeViewFocus.params = {
+  onNodeFocus: true
+};

package/modern/internals/plugins/useTreeViewId/useTreeViewId.js

@@ -15,4 +15,7 @@ export const useTreeViewId = ({
       id: treeId
     })
   };
+};
+useTreeViewId.params = {
+  id: true
 };

package/modern/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.js

@@ -110,4 +110,5 @@ const useTreeViewJSXNodesItemPlugin = ({
     })
   };
 };
-useTreeViewJSXNodes.itemPlugin = useTreeViewJSXNodesItemPlugin;
+useTreeViewJSXNodes.itemPlugin = useTreeViewJSXNodesItemPlugin;
+useTreeViewJSXNodes.params = {};

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

@@ -3,7 +3,7 @@ import { useTheme } from '@mui/material/styles';
 import useEventCallback from '@mui/utils/useEventCallback';
 import { getFirstNode, getLastNode, getNextNode, getPreviousNode, populateInstance } from '../../useTreeView/useTreeView.utils';
 function isPrintableCharacter(string) {
-  return string && string.length === 1 && string.match(/\S/);
+  return !!string && string.length === 1 && !!string.match(/\S/);
 }
 function findNextFirstChar(firstChars, startIndex, char) {
   for (let i = startIndex; i < firstChars.length; i += 1) {
@@ -19,7 +19,7 @@ export const useTreeViewKeyboardNavigation = ({
   state
 }) => {
   const theme = useTheme();
-  const isRtl = theme.direction === 'rtl';
+  const isRTL = theme.direction === 'rtl';
   const firstCharMap = React.useRef({});
   const hasFirstCharMapBeenUpdatedImperatively = React.useRef(false);
   const updateFirstCharMap = useEventCallback(callback => {
@@ -43,32 +43,7 @@ export const useTreeViewKeyboardNavigation = ({
   populateInstance(instance, {
     updateFirstCharMap
   });
-  const handleNextArrow = event => {
-    if (state.focusedNodeId != null && instance.isNodeExpandable(state.focusedNodeId)) {
-      if (instance.isNodeExpanded(state.focusedNodeId)) {
-        instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
-      } else if (!instance.isNodeDisabled(state.focusedNodeId)) {
-        instance.toggleNodeExpansion(event, state.focusedNodeId);
-      }
-    }
-    return true;
-  };
-  const handlePreviousArrow = event => {
-    if (state.focusedNodeId == null) {
-      return false;
-    }
-    if (instance.isNodeExpanded(state.focusedNodeId) && !instance.isNodeDisabled(state.focusedNodeId)) {
-      instance.toggleNodeExpansion(event, state.focusedNodeId);
-      return true;
-    }
-    const parent = instance.getNode(state.focusedNodeId).parentId;
-    if (parent) {
-      instance.focusNode(event, parent);
-      return true;
-    }
-    return false;
-  };
-  const focusByFirstCharacter = (event, nodeId, firstChar) => {
+  const getFirstMatchingNode = (nodeId, firstChar) => {
     let start;
     let index;
     const lowercaseChar = firstChar.toLowerCase();
@@ -99,41 +74,35 @@ export const useTreeViewKeyboardNavigation = ({
       index = findNextFirstChar(firstChars, 0, lowercaseChar);
     }
 
-    // If match was found...
+    // If a match was found...
     if (index > -1) {
-      instance.focusNode(event, firstCharIds[index]);
-    }
-  };
-  const selectNextNode = (event, id) => {
-    if (!instance.isNodeDisabled(getNextNode(instance, id))) {
-      instance.selectRange(event, {
-        end: getNextNode(instance, id),
-        current: id
-      }, true);
-    }
-  };
-  const selectPreviousNode = (event, nodeId) => {
-    if (!instance.isNodeDisabled(getPreviousNode(instance, nodeId))) {
-      instance.selectRange(event, {
-        end: getPreviousNode(instance, nodeId),
-        current: nodeId
-      }, true);
+      return firstCharIds[index];
     }
+    return null;
   };
+  const canToggleNodeSelection = nodeId => !params.disableSelection && !instance.isNodeDisabled(nodeId);
+  const canToggleNodeExpansion = nodeId => !instance.isNodeDisabled(nodeId) && instance.isNodeExpandable(nodeId);
+
+  // ARIA specification: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/#keyboardinteraction
   const createHandleKeyDown = otherHandlers => event => {
     otherHandlers.onKeyDown?.(event);
-    let flag = false;
-    const key = event.key;
+    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) {
       return;
     }
     const ctrlPressed = event.ctrlKey || event.metaKey;
-    switch (key) {
-      case ' ':
-        if (!params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-          flag = true;
+    const key = event.key;
+
+    // eslint-disable-next-line default-case
+    switch (true) {
+      // Select the node when pressing "Space"
+      case key === ' ' && canToggleNodeSelection(state.focusedNodeId):
+        {
+          event.preventDefault();
           if (params.multiSelect && event.shiftKey) {
             instance.selectRange(event, {
               end: state.focusedNodeId
@@ -143,85 +112,158 @@ export const useTreeViewKeyboardNavigation = ({
           } else {
             instance.selectNode(event, state.focusedNodeId);
           }
+          break;
         }
-        event.stopPropagation();
-        break;
-      case 'Enter':
-        if (!instance.isNodeDisabled(state.focusedNodeId)) {
-          if (instance.isNodeExpandable(state.focusedNodeId)) {
+
+      // If the focused node has children, we expand it.
+      // If the focused node has no children, we select it.
+      case key === 'Enter':
+        {
+          if (canToggleNodeExpansion(state.focusedNodeId)) {
             instance.toggleNodeExpansion(event, state.focusedNodeId);
-            flag = true;
-          } else if (!params.disableSelection) {
-            flag = true;
+            event.preventDefault();
+          } else if (canToggleNodeSelection(state.focusedNodeId)) {
             if (params.multiSelect) {
+              event.preventDefault();
               instance.selectNode(event, state.focusedNodeId, true);
-            } else {
+            } else if (!instance.isNodeSelected(state.focusedNodeId)) {
               instance.selectNode(event, state.focusedNodeId);
+              event.preventDefault();
             }
           }
+          break;
         }
-        event.stopPropagation();
-        break;
-      case 'ArrowDown':
-        if (params.multiSelect && event.shiftKey && !params.disableSelection) {
-          selectNextNode(event, state.focusedNodeId);
+
+      // Focus the next focusable node
+      case key === 'ArrowDown':
+        {
+          const nextNode = getNextNode(instance, state.focusedNodeId);
+          if (nextNode) {
+            event.preventDefault();
+            instance.focusNode(event, nextNode);
+
+            // Multi select behavior when pressing Shift + ArrowDown
+            // Toggles the selection state of the next node
+            if (params.multiSelect && event.shiftKey && canToggleNodeSelection(nextNode)) {
+              instance.selectRange(event, {
+                end: nextNode,
+                current: state.focusedNodeId
+              }, true);
+            }
+          }
+          break;
         }
-        instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
-        flag = true;
-        break;
-      case 'ArrowUp':
-        if (params.multiSelect && event.shiftKey && !params.disableSelection) {
-          selectPreviousNode(event, state.focusedNodeId);
+
+      // Focuses the previous focusable node
+      case key === 'ArrowUp':
+        {
+          const previousNode = getPreviousNode(instance, state.focusedNodeId);
+          if (previousNode) {
+            event.preventDefault();
+            instance.focusNode(event, previousNode);
+
+            // Multi select behavior when pressing Shift + ArrowUp
+            // Toggles the selection state of the previous node
+            if (params.multiSelect && event.shiftKey && canToggleNodeSelection(previousNode)) {
+              instance.selectRange(event, {
+                end: previousNode,
+                current: state.focusedNodeId
+              }, true);
+            }
+          }
+          break;
         }
-        instance.focusNode(event, getPreviousNode(instance, state.focusedNodeId));
-        flag = true;
-        break;
-      case 'ArrowRight':
-        if (isRtl) {
-          flag = handlePreviousArrow(event);
-        } else {
-          flag = handleNextArrow(event);
+
+      // 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
+      case key === 'ArrowRight' && !isRTL || key === 'ArrowLeft' && isRTL:
+        {
+          if (instance.isNodeExpanded(state.focusedNodeId)) {
+            instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
+            event.preventDefault();
+          } else if (canToggleNodeExpansion(state.focusedNodeId)) {
+            instance.toggleNodeExpansion(event, state.focusedNodeId);
+            event.preventDefault();
+          }
+          break;
         }
-        break;
-      case 'ArrowLeft':
-        if (isRtl) {
-          flag = handleNextArrow(event);
-        } else {
-          flag = handlePreviousArrow(event);
+
+      // 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
+      case key === 'ArrowLeft' && !isRTL || key === 'ArrowRight' && isRTL:
+        {
+          if (canToggleNodeExpansion(state.focusedNodeId) && instance.isNodeExpanded(state.focusedNodeId)) {
+            instance.toggleNodeExpansion(event, state.focusedNodeId);
+            event.preventDefault();
+          } else {
+            const parent = instance.getNode(state.focusedNodeId).parentId;
+            if (parent) {
+              instance.focusNode(event, parent);
+              event.preventDefault();
+            }
+          }
+          break;
         }
-        break;
-      case 'Home':
-        if (params.multiSelect && ctrlPressed && event.shiftKey && !params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-          instance.rangeSelectToFirst(event, state.focusedNodeId);
+
+      // Focuses the first node in the tree
+      case key === 'Home':
+        {
+          instance.focusNode(event, getFirstNode(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);
+          }
+          event.preventDefault();
+          break;
         }
-        instance.focusNode(event, getFirstNode(instance));
-        flag = true;
-        break;
-      case 'End':
-        if (params.multiSelect && ctrlPressed && event.shiftKey && !params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-          instance.rangeSelectToLast(event, state.focusedNodeId);
+
+      // Focuses the last node in the tree
+      case key === 'End':
+        {
+          instance.focusNode(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);
+          }
+          event.preventDefault();
+          break;
         }
-        instance.focusNode(event, getLastNode(instance));
-        flag = true;
-        break;
-      default:
-        if (key === '*') {
+
+      // Expand all siblings that are at the same level as the focused node
+      case key === '*':
+        {
           instance.expandAllSiblings(event, state.focusedNodeId);
-          flag = true;
-        } else if (params.multiSelect && ctrlPressed && key.toLowerCase() === 'a' && !params.disableSelection) {
+          event.preventDefault();
+          break;
+        }
+
+      // Multi select behavior when pressing Ctrl + a
+      // Selects all the nodes
+      case key === 'a' && ctrlPressed && params.multiSelect && !params.disableSelection:
+        {
           instance.selectRange(event, {
             start: getFirstNode(instance),
             end: getLastNode(instance)
           });
-          flag = true;
-        } else if (!ctrlPressed && !event.shiftKey && isPrintableCharacter(key)) {
-          focusByFirstCharacter(event, state.focusedNodeId, key);
-          flag = true;
+          event.preventDefault();
+          break;
+        }
+
+      // Type-ahead
+      // TODO: Support typing multiple characters
+      case !ctrlPressed && !event.shiftKey && isPrintableCharacter(key):
+        {
+          const matchingNode = getFirstMatchingNode(state.focusedNodeId, key);
+          if (matchingNode != null) {
+            instance.focusNode(event, matchingNode);
+            event.preventDefault();
+          }
+          break;
         }
-    }
-    if (flag) {
-      event.preventDefault();
-      event.stopPropagation();
     }
   };
   return {
@@ -229,4 +271,5 @@ export const useTreeViewKeyboardNavigation = ({
       onKeyDown: createHandleKeyDown(otherHandlers)
     })
   };
-};
+};
+useTreeViewKeyboardNavigation.params = {};