@mui/x-tree-view 7.12.0 → 7.13.0

package/modern/RichTreeView/RichTreeView.js

@@ -140,7 +140,8 @@ process.env.NODE_ENV !== "production" ? RichTreeView.propTypes = {
       getItemOrderedChildrenIds: PropTypes.func.isRequired,
       getItemTree: PropTypes.func.isRequired,
       selectItem: PropTypes.func.isRequired,
-      setItemExpansion: PropTypes.func.isRequired
+      setItemExpansion: PropTypes.func.isRequired,
+      updateItemLabel: PropTypes.func.isRequired
     })
   }),
   /**
@@ -191,7 +192,8 @@ process.env.NODE_ENV !== "production" ? RichTreeView.propTypes = {
    * the feature will be fully disabled and any property / method call will not have any effect.
    */
   experimentalFeatures: PropTypes.shape({
-    indentationAtItemLevel: PropTypes.bool
+    indentationAtItemLevel: PropTypes.bool,
+    labelEditing: PropTypes.bool
   }),
   /**
    * Used to determine the id of a given item.
@@ -223,6 +225,16 @@ process.env.NODE_ENV !== "production" ? RichTreeView.propTypes = {
    * @returns {boolean} `true` if the item should be disabled.
    */
   isItemDisabled: PropTypes.func,
+  /**
+   * Determines if a given item is editable or not.
+   * Make sure to also enable the `labelEditing` experimental feature:
+   * `<RichTreeViewPro experimentalFeatures={{ labelEditing: true }}  />`.
+   * By default, the items are not editable.
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {boolean} `true` if the item is editable.
+   */
+  isItemEditable: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),
   /**
    * Horizontal indentation between an item and its children.
    * Examples: 24, "24px", "2rem", "2em".
@@ -260,6 +272,12 @@ process.env.NODE_ENV !== "production" ? RichTreeView.propTypes = {
    * @param {string} itemId The id of the focused item.
    */
   onItemFocus: PropTypes.func,
+  /**
+   * Callback fired when the label of an item changes.
+   * @param {TreeViewItemId} itemId The id of the item that was edited.
+   * @param {string} newLabel The new label of the items.
+   */
+  onItemLabelChange: PropTypes.func,
   /**
    * Callback fired when a tree item is selected or deselected.
    * @param {React.SyntheticEvent} event The DOM event that triggered the change.

package/modern/RichTreeView/RichTreeView.plugins.js

@@ -4,6 +4,7 @@ import { useTreeViewSelection } from '../internals/plugins/useTreeViewSelection'
 import { useTreeViewFocus } from '../internals/plugins/useTreeViewFocus';
 import { useTreeViewKeyboardNavigation } from '../internals/plugins/useTreeViewKeyboardNavigation';
 import { useTreeViewIcons } from '../internals/plugins/useTreeViewIcons';
-export const RICH_TREE_VIEW_PLUGINS = [useTreeViewItems, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewIcons];
+import { useTreeViewLabel } from '../internals/plugins/useTreeViewLabel';
+export const RICH_TREE_VIEW_PLUGINS = [useTreeViewItems, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewIcons, useTreeViewLabel];
 
 // We can't infer this type from the plugin, otherwise we would lose the generics.

package/modern/TreeItem/TreeItem.js

@@ -25,6 +25,7 @@ import { TreeViewCollapseIcon, TreeViewExpandIcon } from '../icons';
 import { TreeItem2Provider } from '../TreeItem2Provider';
 import { TreeViewItemDepthContext } from '../internals/TreeViewItemDepthContext';
 import { useTreeItemState } from './useTreeItemState';
+import { isTargetInDescendants } from '../internals/utils/tree';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const useThemeProps = createUseThemeProps('MuiTreeItem');
 const useUtilityClasses = ownerState => {
@@ -41,6 +42,9 @@ const useUtilityClasses = ownerState => {
     iconContainer: ['iconContainer'],
     checkbox: ['checkbox'],
     label: ['label'],
+    labelInput: ['labelInput'],
+    editing: ['editing'],
+    editable: ['editable'],
     groupTransition: ['groupTransition']
   };
   return composeClasses(slots, getTreeItemUtilityClass, classes);
@@ -207,6 +211,7 @@ export const TreeItem = /*#__PURE__*/React.forwardRef(function TreeItem(inProps,
     focused,
     selected,
     disabled,
+    editing,
     handleExpansion
   } = useTreeItemState(itemId);
   const {
@@ -317,10 +322,19 @@ export const TreeItem = /*#__PURE__*/React.forwardRef(function TreeItem(inProps,
   }
   function handleBlur(event) {
     onBlur?.(event);
+    if (editing ||
+    // we can exit the editing state by clicking outside the input (within the tree item) or by pressing Enter or Escape -> we don't want to remove the focused item from the state in these cases
+    // we can also exit the editing state by clicking on the root itself -> want to remove the focused item from the state in this case
+    event.relatedTarget && isTargetInDescendants(event.relatedTarget, rootRefObject.current) && (event.target && event.target?.dataset?.element === 'labelInput' && isTargetInDescendants(event.target, rootRefObject.current) || event.relatedTarget?.dataset?.element === 'labelInput')) {
+      return;
+    }
     instance.removeFocusedItem();
   }
   const handleKeyDown = event => {
     onKeyDown?.(event);
+    if (event.target?.dataset?.element === 'labelInput') {
+      return;
+    }
     instance.handleItemKeyDown(event, itemId);
   };
   const idAttribute = instance.getTreeItemIdAttribute(itemId, id);
@@ -340,6 +354,11 @@ export const TreeItem = /*#__PURE__*/React.forwardRef(function TreeItem(inProps,
     contentRefObject,
     externalEventHandlers: {}
   }) ?? {};
+  const enhancedLabelInputProps = propsEnhancers.labelInput?.({
+    rootRefObject,
+    contentRefObject,
+    externalEventHandlers: {}
+  }) ?? {};
   return /*#__PURE__*/_jsx(TreeItem2Provider, {
     itemId: itemId,
     children: /*#__PURE__*/_jsxs(TreeItemRoot, _extends({
@@ -368,8 +387,11 @@ export const TreeItem = /*#__PURE__*/React.forwardRef(function TreeItem(inProps,
           selected: classes.selected,
           focused: classes.focused,
           disabled: classes.disabled,
+          editable: classes.editable,
+          editing: classes.editing,
           iconContainer: classes.iconContainer,
           label: classes.label,
+          labelInput: classes.labelInput,
           checkbox: classes.checkbox
         },
         label: label,
@@ -382,6 +404,8 @@ export const TreeItem = /*#__PURE__*/React.forwardRef(function TreeItem(inProps,
         ownerState: ownerState
       }, ContentProps, enhancedContentProps, enhancedDragAndDropOverlayProps.action == null ? {} : {
         dragAndDropOverlayProps: enhancedDragAndDropOverlayProps
+      }, enhancedLabelInputProps.value == null ? {} : {
+        labelInputProps: enhancedLabelInputProps
       }, {
         ref: handleContentRef
       })), children && /*#__PURE__*/_jsx(TreeItemGroup, _extends({

package/modern/TreeItem/TreeItemContent.js

@@ -1,12 +1,13 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["classes", "className", "displayIcon", "expansionIcon", "icon", "label", "itemId", "onClick", "onMouseDown", "dragAndDropOverlayProps"];
+const _excluded = ["classes", "className", "displayIcon", "expansionIcon", "icon", "label", "itemId", "onClick", "onMouseDown", "dragAndDropOverlayProps", "labelInputProps"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import clsx from 'clsx';
 import Checkbox from '@mui/material/Checkbox';
 import { useTreeItemState } from './useTreeItemState';
 import { TreeItem2DragAndDropOverlay } from '../TreeItem2DragAndDropOverlay';
+import { TreeItem2LabelInput } from '../TreeItem2LabelInput';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * @ignore - internal component.
@@ -22,7 +23,8 @@ const TreeItemContent = /*#__PURE__*/React.forwardRef(function TreeItemContent(p
       itemId,
       onClick,
       onMouseDown,
-      dragAndDropOverlayProps
+      dragAndDropOverlayProps,
+      labelInputProps
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
   const {
@@ -30,6 +32,8 @@ const TreeItemContent = /*#__PURE__*/React.forwardRef(function TreeItemContent(p
     expanded,
     selected,
     focused,
+    editing,
+    editable,
     disableSelection,
     checkboxSelection,
     handleExpansion,
@@ -37,7 +41,10 @@ const TreeItemContent = /*#__PURE__*/React.forwardRef(function TreeItemContent(p
     handleCheckboxSelection,
     handleContentClick,
     preventSelection,
-    expansionTrigger
+    expansionTrigger,
+    toggleItemEditing,
+    handleSaveItemLabel,
+    handleCancelItemLabelEditing
   } = useTreeItemState(itemId);
   const icon = iconProp || expansionIcon || displayIcon;
   const checkboxRef = React.useRef(null);
@@ -62,11 +69,36 @@ const TreeItemContent = /*#__PURE__*/React.forwardRef(function TreeItemContent(p
       onClick(event);
     }
   };
+  const handleLabelDoubleClick = event => {
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    toggleItemEditing();
+  };
+  const handleLabelInputBlur = event => {
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    if (event.target.value) {
+      handleSaveItemLabel(event, event.target.value);
+    }
+  };
+  const handleLabelInputKeydown = event => {
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    const target = event.target;
+    if (event.key === 'Enter' && target.value) {
+      handleSaveItemLabel(event, target.value);
+    } else if (event.key === 'Escape') {
+      handleCancelItemLabelEditing(event);
+    }
+  };
   return (
     /*#__PURE__*/
     /* eslint-disable-next-line jsx-a11y/click-events-have-key-events,jsx-a11y/no-static-element-interactions -- Key event is handled by the TreeView */
     _jsxs("div", _extends({}, other, {
-      className: clsx(className, classes.root, expanded && classes.expanded, selected && classes.selected, focused && classes.focused, disabled && classes.disabled),
+      className: clsx(className, classes.root, expanded && classes.expanded, selected && classes.selected, focused && classes.focused, disabled && classes.disabled, editing && classes.editing, editable && classes.editable),
       onClick: handleClick,
       onMouseDown: handleMouseDown,
       ref: ref,
@@ -80,10 +112,17 @@ const TreeItemContent = /*#__PURE__*/React.forwardRef(function TreeItemContent(p
         disabled: disabled || disableSelection,
         ref: checkboxRef,
         tabIndex: -1
-      }), /*#__PURE__*/_jsx("div", {
-        className: classes.label,
+      }), editing ? /*#__PURE__*/_jsx(TreeItem2LabelInput, _extends({}, labelInputProps, {
+        className: classes.labelInput,
+        onBlur: handleLabelInputBlur,
+        onKeyDown: handleLabelInputKeydown
+      })) : /*#__PURE__*/_jsx("div", _extends({
+        className: classes.label
+      }, editable && {
+        onDoubleClick: handleLabelDoubleClick
+      }, {
         children: label
-      }), dragAndDropOverlayProps && /*#__PURE__*/_jsx(TreeItem2DragAndDropOverlay, _extends({}, dragAndDropOverlayProps))]
+      })), dragAndDropOverlayProps && /*#__PURE__*/_jsx(TreeItem2DragAndDropOverlay, _extends({}, dragAndDropOverlayProps))]
     }))
   );
 });
@@ -120,6 +159,7 @@ process.env.NODE_ENV !== "production" ? TreeItemContent.propTypes = {
   /**
    * The tree item label.
    */
-  label: PropTypes.node
+  label: PropTypes.node,
+  labelInputProps: PropTypes.object
 } : void 0;
 export { TreeItemContent };

package/modern/TreeItem/treeItemClasses.js

@@ -3,4 +3,4 @@ import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
 export function getTreeItemUtilityClass(slot) {
   return generateUtilityClass('MuiTreeItem', slot);
 }
-export const treeItemClasses = generateUtilityClasses('MuiTreeItem', ['root', 'groupTransition', 'content', 'expanded', 'selected', 'focused', 'disabled', 'iconContainer', 'label', 'checkbox', 'dragAndDropOverlay']);
+export const treeItemClasses = generateUtilityClasses('MuiTreeItem', ['root', 'groupTransition', 'content', 'expanded', 'selected', 'focused', 'disabled', 'iconContainer', 'label', 'checkbox', 'labelInput', 'editable', 'editing', 'dragAndDropOverlay']);

package/modern/TreeItem/useTreeItemState.js

@@ -1,4 +1,6 @@
 import { useTreeViewContext } from '../internals/TreeViewProvider';
+import { useTreeViewLabel } from '../internals/plugins/useTreeViewLabel';
+import { hasPlugin } from '../internals/utils/plugins';
 export function useTreeItemState(itemId) {
   const {
     instance,
@@ -19,6 +21,8 @@ export function useTreeItemState(itemId) {
   const focused = instance.isItemFocused(itemId);
   const selected = instance.isItemSelected(itemId);
   const disabled = instance.isItemDisabled(itemId);
+  const editing = instance?.isItemBeingEdited ? instance?.isItemBeingEdited(itemId) : false;
+  const editable = instance.isItemEditable ? instance.isItemEditable(itemId) : false;
   const handleExpansion = event => {
     if (!disabled) {
       if (!focused) {
@@ -79,11 +83,49 @@ export function useTreeItemState(itemId) {
       event.preventDefault();
     }
   };
+  const toggleItemEditing = () => {
+    if (!hasPlugin(instance, useTreeViewLabel)) {
+      return;
+    }
+    if (instance.isItemEditable(itemId)) {
+      if (instance.isItemBeingEdited(itemId)) {
+        instance.setEditedItemId(null);
+      } else {
+        instance.setEditedItemId(itemId);
+      }
+    }
+  };
+  const handleSaveItemLabel = (event, label) => {
+    if (!hasPlugin(instance, useTreeViewLabel)) {
+      return;
+    }
+
+    // As a side effect of `instance.focusItem` called here and in `handleCancelItemLabelEditing` the `labelInput` is blurred
+    // The `onBlur` event is triggered, which calls `handleSaveItemLabel` again.
+    // To avoid creating an unwanted behavior we need to check if the item is being edited before calling `updateItemLabel`
+    // using `instance.isItemBeingEditedRef` instead of `instance.isItemBeingEdited` since the state is not yet updated in this point
+    if (instance.isItemBeingEditedRef(itemId)) {
+      instance.updateItemLabel(itemId, label);
+      toggleItemEditing();
+      instance.focusItem(event, itemId);
+    }
+  };
+  const handleCancelItemLabelEditing = event => {
+    if (!hasPlugin(instance, useTreeViewLabel)) {
+      return;
+    }
+    if (instance.isItemBeingEditedRef(itemId)) {
+      toggleItemEditing();
+      instance.focusItem(event, itemId);
+    }
+  };
   return {
     disabled,
     expanded,
     selected,
     focused,
+    editable,
+    editing,
     disableSelection,
     checkboxSelection,
     handleExpansion,
@@ -91,6 +133,9 @@ export function useTreeItemState(itemId) {
     handleCheckboxSelection,
     handleContentClick: onItemClick,
     preventSelection,
-    expansionTrigger
+    expansionTrigger,
+    toggleItemEditing,
+    handleSaveItemLabel,
+    handleCancelItemLabelEditing
   };
 }

package/modern/TreeItem2/TreeItem2.js

@@ -18,6 +18,7 @@ import { getTreeItemUtilityClass } from '../TreeItem';
 import { TreeItem2Icon } from '../TreeItem2Icon';
 import { TreeItem2DragAndDropOverlay } from '../TreeItem2DragAndDropOverlay';
 import { TreeItem2Provider } from '../TreeItem2Provider';
+import { TreeItem2LabelInput } from '../TreeItem2LabelInput';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const useThemeProps = createUseThemeProps('MuiTreeItem2');
 export const TreeItem2Root = styled('li', {
@@ -104,7 +105,8 @@ export const TreeItem2Content = styled('div', {
 export const TreeItem2Label = styled('div', {
   name: 'MuiTreeItem2',
   slot: 'Label',
-  overridesResolver: (props, styles) => styles.label
+  overridesResolver: (props, styles) => styles.label,
+  shouldForwardProp: prop => shouldForwardProp(prop) && prop !== 'editable'
 })(({
   theme
 }) => _extends({
@@ -113,8 +115,18 @@ export const TreeItem2Label = styled('div', {
   // prevent width + padding to overflow
   // fixes overflow - see https://github.com/mui/material-ui/issues/27372
   minWidth: 0,
-  position: 'relative'
-}, theme.typography.body1));
+  position: 'relative',
+  overflow: 'hidden'
+}, theme.typography.body1, {
+  variants: [{
+    props: ({
+      editable
+    }) => editable,
+    style: {
+      paddingLeft: '2px'
+    }
+  }]
+}));
 export const TreeItem2IconContainer = styled('div', {
   name: 'MuiTreeItem2',
   slot: 'IconContainer',
@@ -172,6 +184,8 @@ const useUtilityClasses = ownerState => {
     root: ['root'],
     content: ['content'],
     expanded: ['expanded'],
+    editing: ['editing'],
+    editable: ['editable'],
     selected: ['selected'],
     focused: ['focused'],
     disabled: ['disabled'],
@@ -179,6 +193,7 @@ const useUtilityClasses = ownerState => {
     checkbox: ['checkbox'],
     label: ['label'],
     groupTransition: ['groupTransition'],
+    labelInput: ['labelInput'],
     dragAndDropOverlay: ['dragAndDropOverlay']
   };
   return composeClasses(slots, getTreeItemUtilityClass, classes);
@@ -215,6 +230,7 @@ export const TreeItem2 = /*#__PURE__*/React.forwardRef(function TreeItem2(inProp
     getCheckboxProps,
     getLabelProps,
     getGroupTransitionProps,
+    getLabelInputProps,
     getDragAndDropOverlayProps,
     status
   } = useTreeItem2({
@@ -244,7 +260,7 @@ export const TreeItem2 = /*#__PURE__*/React.forwardRef(function TreeItem2(inProp
     getSlotProps: getContentProps,
     externalSlotProps: slotProps.content,
     ownerState: {},
-    className: clsx(classes.content, status.expanded && classes.expanded, status.selected && classes.selected, status.focused && classes.focused, status.disabled && classes.disabled)
+    className: clsx(classes.content, status.expanded && classes.expanded, status.selected && classes.selected, status.focused && classes.focused, status.disabled && classes.disabled, status.editing && classes.editing, status.editable && classes.editable)
   });
   const IconContainer = slots.iconContainer ?? TreeItem2IconContainer;
   const iconContainerProps = useSlotProps({
@@ -278,6 +294,14 @@ export const TreeItem2 = /*#__PURE__*/React.forwardRef(function TreeItem2(inProp
     ownerState: {},
     className: classes.groupTransition
   });
+  const LabelInput = slots.labelInput ?? TreeItem2LabelInput;
+  const labelInputProps = useSlotProps({
+    elementType: LabelInput,
+    getSlotProps: getLabelInputProps,
+    externalSlotProps: slotProps.labelInput,
+    ownerState: {},
+    className: classes.labelInput
+  });
   const DragAndDropOverlay = slots.dragAndDropOverlay ?? TreeItem2DragAndDropOverlay;
   const dragAndDropOverlayProps = useSlotProps({
     elementType: DragAndDropOverlay,
@@ -296,7 +320,7 @@ export const TreeItem2 = /*#__PURE__*/React.forwardRef(function TreeItem2(inProp
             slots: slots,
             slotProps: slotProps
           })
-        })), /*#__PURE__*/_jsx(Checkbox, _extends({}, checkboxProps)), /*#__PURE__*/_jsx(Label, _extends({}, labelProps)), /*#__PURE__*/_jsx(DragAndDropOverlay, _extends({}, dragAndDropOverlayProps))]
+        })), /*#__PURE__*/_jsx(Checkbox, _extends({}, checkboxProps)), status.editing ? /*#__PURE__*/_jsx(LabelInput, _extends({}, labelInputProps)) : /*#__PURE__*/_jsx(Label, _extends({}, labelProps)), /*#__PURE__*/_jsx(DragAndDropOverlay, _extends({}, dragAndDropOverlayProps))]
       })), children && /*#__PURE__*/_jsx(TreeItem2GroupTransition, _extends({
         as: GroupTransition
       }, groupTransitionProps))]

package/modern/TreeItem2Icon/TreeItem2Icon.js

@@ -59,6 +59,8 @@ process.env.NODE_ENV !== "production" ? TreeItem2Icon.propTypes = {
   slots: PropTypes.object,
   status: PropTypes.shape({
     disabled: PropTypes.bool.isRequired,
+    editable: PropTypes.bool.isRequired,
+    editing: PropTypes.bool.isRequired,
     expandable: PropTypes.bool.isRequired,
     expanded: PropTypes.bool.isRequired,
     focused: PropTypes.bool.isRequired,

package/modern/TreeItem2LabelInput/TreeItem2LabelInput.js

@@ -0,0 +1,20 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { styled } from '../internals/zero-styled';
+const TreeItem2LabelInput = styled('input', {
+  name: 'MuiTreeItem2',
+  slot: 'LabelInput',
+  overridesResolver: (props, styles) => styles.labelInput
+})(({
+  theme
+}) => _extends({}, theme.typography.body1, {
+  width: '100%',
+  backgroundColor: theme.palette.background.paper,
+  borderRadius: theme.shape.borderRadius,
+  border: 'none',
+  padding: '0 2px',
+  boxSizing: 'border-box',
+  '&:focus': {
+    outline: `1px solid ${theme.palette.primary.main}`
+  }
+}));
+export { TreeItem2LabelInput };

package/modern/TreeItem2LabelInput/TreeItem2LabelInput.types.js

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

package/modern/TreeItem2LabelInput/index.js

@@ -0,0 +1 @@
+export { TreeItem2LabelInput } from './TreeItem2LabelInput';

package/modern/hooks/useTreeItem2Utils/useTreeItem2Utils.js

@@ -1,4 +1,6 @@
 import { useTreeViewContext } from '../../internals/TreeViewProvider';
+import { useTreeViewLabel } from '../../internals/plugins/useTreeViewLabel';
+import { hasPlugin } from '../../internals/utils/plugins';
 const isItemExpandable = reactChildren => {
   if (Array.isArray(reactChildren)) {
     return reactChildren.length > 0 && reactChildren.some(isItemExpandable);
@@ -29,7 +31,9 @@ export const useTreeItem2Utils = ({
     expanded: instance.isItemExpanded(itemId),
     focused: instance.isItemFocused(itemId),
     selected: instance.isItemSelected(itemId),
-    disabled: instance.isItemDisabled(itemId)
+    disabled: instance.isItemDisabled(itemId),
+    editing: instance?.isItemBeingEdited ? instance?.isItemBeingEdited(itemId) : false,
+    editable: instance.isItemEditable ? instance.isItemEditable(itemId) : false
   };
   const handleExpansion = event => {
     if (status.disabled) {
@@ -84,10 +88,49 @@ export const useTreeItem2Utils = ({
       });
     }
   };
+  const toggleItemEditing = () => {
+    if (!hasPlugin(instance, useTreeViewLabel)) {
+      return;
+    }
+    if (instance.isItemEditable(itemId)) {
+      if (instance.isItemBeingEdited(itemId)) {
+        instance.setEditedItemId(null);
+      } else {
+        instance.setEditedItemId(itemId);
+      }
+    }
+  };
+  const handleSaveItemLabel = (event, label) => {
+    if (!hasPlugin(instance, useTreeViewLabel)) {
+      return;
+    }
+
+    // As a side effect of `instance.focusItem` called here and in `handleCancelItemLabelEditing` the `labelInput` is blurred
+    // The `onBlur` event is triggered, which calls `handleSaveItemLabel` again.
+    // To avoid creating an unwanted behavior we need to check if the item is being edited before calling `updateItemLabel`
+    // using `instance.isItemBeingEditedRef` instead of `instance.isItemBeingEdited` since the state is not yet updated in this point
+    if (instance.isItemBeingEditedRef(itemId)) {
+      instance.updateItemLabel(itemId, label);
+      toggleItemEditing();
+      instance.focusItem(event, itemId);
+    }
+  };
+  const handleCancelItemLabelEditing = event => {
+    if (!hasPlugin(instance, useTreeViewLabel)) {
+      return;
+    }
+    if (instance.isItemBeingEditedRef(itemId)) {
+      toggleItemEditing();
+      instance.focusItem(event, itemId);
+    }
+  };
   const interactions = {
     handleExpansion,
     handleSelection,
-    handleCheckboxSelection
+    handleCheckboxSelection,
+    toggleItemEditing,
+    handleSaveItemLabel,
+    handleCancelItemLabelEditing
   };
   return {
     interactions,

package/modern/index.js

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

package/modern/internals/index.js

@@ -11,6 +11,7 @@ export { useTreeViewFocus } from './plugins/useTreeViewFocus';
 export { useTreeViewKeyboardNavigation } from './plugins/useTreeViewKeyboardNavigation';
 export { useTreeViewIcons } from './plugins/useTreeViewIcons';
 export { useTreeViewItems, buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from './plugins/useTreeViewItems';
+export { useTreeViewLabel } from './plugins/useTreeViewLabel';
 export { useTreeViewJSXItems } from './plugins/useTreeViewJSXItems';
 export { isTargetInDescendants } from './utils/tree';
 export { warnOnce } from './utils/warning';

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

@@ -57,8 +57,11 @@ export const useTreeViewExpansion = ({
     if (params.expansionTrigger) {
       return params.expansionTrigger;
     }
+    if (instance.isTreeViewEditable) {
+      return 'iconContainer';
+    }
     return 'content';
-  }, [params.expansionTrigger]);
+  }, [params.expansionTrigger, instance.isTreeViewEditable]);
   return {
     publicAPI: {
       setItemExpansion

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

@@ -2,6 +2,8 @@ import * as React from 'react';
 import { useRtl } from '@mui/system/RtlProvider';
 import useEventCallback from '@mui/utils/useEventCallback';
 import { getFirstNavigableItem, getLastNavigableItem, getNextNavigableItem, getPreviousNavigableItem, isTargetInDescendants } from '../../utils/tree';
+import { hasPlugin } from '../../utils/plugins';
+import { useTreeViewLabel } from '../useTreeViewLabel';
 function isPrintableCharacter(string) {
   return !!string && string.length === 1 && !!string.match(/\S/);
 }
@@ -89,7 +91,9 @@ export const useTreeViewKeyboardNavigation = ({
       // If the focused item has no children, we select it.
       case key === 'Enter':
         {
-          if (canToggleItemExpansion(itemId)) {
+          if (hasPlugin(instance, useTreeViewLabel) && instance.isItemEditable(itemId) && !instance.isItemBeingEdited(itemId)) {
+            instance.setEditedItemId(itemId);
+          } else if (canToggleItemExpansion(itemId)) {
             instance.toggleItemExpansion(event, itemId);
             event.preventDefault();
           } else if (canToggleItemSelection(itemId)) {

package/modern/internals/plugins/useTreeViewLabel/index.js

@@ -0,0 +1 @@
+export { useTreeViewLabel } from './useTreeViewLabel';

package/modern/internals/plugins/useTreeViewLabel/useTreeViewLabel.itemPlugin.js

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import { useTreeViewContext } from '../../TreeViewProvider';
+export const isAndroid = () => navigator.userAgent.toLowerCase().includes('android');
+export const useTreeViewLabelItemPlugin = ({
+  props
+}) => {
+  const {
+    instance
+  } = useTreeViewContext();
+  const {
+    label,
+    itemId
+  } = props;
+  const [labelInputValue, setLabelInputValue] = React.useState(label);
+  const isItemBeingEdited = instance.isItemBeingEdited(itemId);
+  React.useEffect(() => {
+    if (!isItemBeingEdited) {
+      setLabelInputValue(label);
+    }
+  }, [isItemBeingEdited, label]);
+  return {
+    propsEnhancers: {
+      labelInput: ({
+        externalEventHandlers
+      }) => {
+        const editable = instance.isItemEditable(itemId);
+        if (!editable) {
+          return {};
+        }
+        const handleInputChange = event => {
+          externalEventHandlers.onChange?.(event);
+          setLabelInputValue(event.target.value);
+        };
+        return {
+          value: labelInputValue ?? '',
+          'data-element': 'labelInput',
+          onChange: handleInputChange,
+          autoFocus: true,
+          type: 'text'
+        };
+      }
+    }
+  };
+};