@mui/x-tree-view 7.6.2 → 7.7.1

package/internals/useTreeView/useTreeView.js

@@ -3,6 +3,7 @@ import * as React from 'react';
 import useForkRef from '@mui/utils/useForkRef';
 import { useTreeViewModels } from './useTreeViewModels';
 import { TREE_VIEW_CORE_PLUGINS } from '../corePlugins';
+import { extractPluginParamsFromProps } from './extractPluginParamsFromProps';
 export function useTreeViewApiInitialization(inputApiRef) {
   const fallbackPublicApiRef = React.useRef({});
   if (inputApiRef) {
@@ -13,62 +14,69 @@ export function useTreeViewApiInitialization(inputApiRef) {
   }
   return fallbackPublicApiRef.current;
 }
-export const useTreeView = inParams => {
-  const plugins = [...TREE_VIEW_CORE_PLUGINS, ...inParams.plugins];
-  const params = plugins.reduce((acc, plugin) => {
-    if (plugin.getDefaultizedParams) {
-      return plugin.getDefaultizedParams(acc);
-    }
-    return acc;
-  }, inParams);
-  const models = useTreeViewModels(plugins, params);
+export const useTreeView = ({
+  plugins: inPlugins,
+  rootRef,
+  props
+}) => {
+  const plugins = [...TREE_VIEW_CORE_PLUGINS, ...inPlugins];
+  const {
+    pluginParams,
+    forwardedProps,
+    apiRef,
+    experimentalFeatures,
+    slots,
+    slotProps
+  } = extractPluginParamsFromProps({
+    plugins,
+    props
+  });
+  const models = useTreeViewModels(plugins, pluginParams);
   const instanceRef = React.useRef({});
   const instance = instanceRef.current;
-  const publicAPI = useTreeViewApiInitialization(inParams.apiRef);
+  const publicAPI = useTreeViewApiInitialization(apiRef);
   const innerRootRef = React.useRef(null);
-  const handleRootRef = useForkRef(innerRootRef, inParams.rootRef);
+  const handleRootRef = useForkRef(innerRootRef, rootRef);
   const [state, setState] = React.useState(() => {
     const temp = {};
     plugins.forEach(plugin => {
       if (plugin.getInitialState) {
-        Object.assign(temp, plugin.getInitialState(params));
+        Object.assign(temp, plugin.getInitialState(pluginParams));
       }
     });
     return temp;
   });
-  const rootPropsGetters = [];
-  const contextValue = {
-    publicAPI,
-    instance: instance,
-    rootRef: innerRootRef
+  const itemWrappers = plugins.map(plugin => plugin.wrapItem).filter(wrapItem => !!wrapItem);
+  const wrapItem = ({
+    itemId,
+    children
+  }) => {
+    let finalChildren = children;
+    itemWrappers.forEach(itemWrapper => {
+      finalChildren = itemWrapper({
+        itemId,
+        children: finalChildren,
+        instance
+      });
+    });
+    return finalChildren;
   };
-  const runPlugin = plugin => {
-    const pluginResponse = plugin({
-      instance,
-      params,
-      slots: params.slots,
-      slotProps: params.slotProps,
-      experimentalFeatures: params.experimentalFeatures,
-      state,
-      setState,
-      rootRef: innerRootRef,
-      models
+  const rootWrappers = plugins.map(plugin => plugin.wrapRoot).filter(wrapRoot => !!wrapRoot)
+  // The wrappers are reversed to ensure that the first wrapper is the outermost one.
+  .reverse();
+  const wrapRoot = ({
+    children
+  }) => {
+    let finalChildren = children;
+    rootWrappers.forEach(rootWrapper => {
+      finalChildren = rootWrapper({
+        children: finalChildren,
+        instance
+      });
     });
-    if (pluginResponse.getRootProps) {
-      rootPropsGetters.push(pluginResponse.getRootProps);
-    }
-    if (pluginResponse.publicAPI) {
-      Object.assign(publicAPI, pluginResponse.publicAPI);
-    }
-    if (pluginResponse.instance) {
-      Object.assign(instance, pluginResponse.instance);
-    }
-    if (pluginResponse.contextValue) {
-      Object.assign(contextValue, pluginResponse.contextValue);
-    }
+    return finalChildren;
   };
-  plugins.forEach(runPlugin);
-  contextValue.runItemPlugins = itemPluginProps => {
+  const runItemPlugins = itemPluginProps => {
     let finalRootRef = null;
     let finalContentRef = null;
     plugins.forEach(plugin => {
@@ -92,40 +100,45 @@ export const useTreeView = inParams => {
       rootRef: finalRootRef
     };
   };
-  const itemWrappers = plugins.map(plugin => plugin.wrapItem).filter(wrapItem => !!wrapItem);
-  contextValue.wrapItem = ({
-    itemId,
-    children
-  }) => {
-    let finalChildren = children;
-    itemWrappers.forEach(itemWrapper => {
-      finalChildren = itemWrapper({
-        itemId,
-        children: finalChildren,
-        instance
-      });
-    });
-    return finalChildren;
+  const contextValue = {
+    publicAPI,
+    wrapItem,
+    wrapRoot,
+    runItemPlugins,
+    instance: instance,
+    rootRef: innerRootRef
   };
-  const rootWrappers = plugins.map(plugin => plugin.wrapRoot).filter(wrapRoot => !!wrapRoot)
-  // The wrappers are reversed to ensure that the first wrapper is the outermost one.
-  .reverse();
-  contextValue.wrapRoot = ({
-    children
-  }) => {
-    let finalChildren = children;
-    rootWrappers.forEach(rootWrapper => {
-      finalChildren = rootWrapper({
-        children: finalChildren,
-        instance
-      });
+  const rootPropsGetters = [];
+  const runPlugin = plugin => {
+    const pluginResponse = plugin({
+      instance,
+      params: pluginParams,
+      slots,
+      slotProps,
+      experimentalFeatures,
+      state,
+      setState,
+      rootRef: innerRootRef,
+      models
     });
-    return finalChildren;
+    if (pluginResponse.getRootProps) {
+      rootPropsGetters.push(pluginResponse.getRootProps);
+    }
+    if (pluginResponse.publicAPI) {
+      Object.assign(publicAPI, pluginResponse.publicAPI);
+    }
+    if (pluginResponse.instance) {
+      Object.assign(instance, pluginResponse.instance);
+    }
+    if (pluginResponse.contextValue) {
+      Object.assign(contextValue, pluginResponse.contextValue);
+    }
   };
+  plugins.forEach(runPlugin);
   const getRootProps = (otherHandlers = {}) => {
     const rootProps = _extends({
       role: 'tree'
-    }, otherHandlers, {
+    }, forwardedProps, otherHandlers, {
       ref: handleRootRef
     });
     rootPropsGetters.forEach(rootPropsGetter => {
@@ -136,7 +149,7 @@ export const useTreeView = inParams => {
   return {
     getRootProps,
     rootRef: handleRootRef,
-    contextValue: contextValue,
-    instance: instance
+    contextValue,
+    instance
   };
 };

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

@@ -1,23 +1,24 @@
 import * as React from 'react';
 import { EventHandlers } from '@mui/base/utils';
 import type { TreeViewContextValue } from '../TreeViewProvider';
-import { TreeViewAnyPluginSignature, TreeViewPlugin, ConvertPluginsIntoSignatures, MergePluginsProperty, TreeViewInstance, TreeViewPublicAPI, TreeViewExperimentalFeatures } from '../models';
-export type UseTreeViewParameters<TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]> = UseTreeViewBaseParameters<TPlugins> & MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'params'>;
-export interface UseTreeViewBaseParameters<TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]> {
-    apiRef: React.MutableRefObject<TreeViewPublicAPI<ConvertPluginsIntoSignatures<TPlugins>>> | undefined;
+import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewInstance, TreeViewPublicAPI, TreeViewExperimentalFeatures } from '../models';
+export interface UseTreeViewParameters<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> {
+    plugins: ConvertSignaturesIntoPlugins<TSignatures>;
     rootRef?: React.Ref<HTMLUListElement> | undefined;
-    plugins: TPlugins;
-    slots: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'slots'>;
-    slotProps: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'slotProps'>;
-    experimentalFeatures: TreeViewExperimentalFeatures<ConvertPluginsIntoSignatures<TPlugins>>;
+    props: TProps;
+}
+export interface UseTreeViewBaseProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
+    apiRef: React.MutableRefObject<TreeViewPublicAPI<TSignatures> | undefined> | undefined;
+    slots: MergeSignaturesProperty<TSignatures, 'slots'>;
+    slotProps: MergeSignaturesProperty<TSignatures, 'slotProps'>;
+    experimentalFeatures: TreeViewExperimentalFeatures<TSignatures>;
 }
-export type UseTreeViewDefaultizedParameters<TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]> = UseTreeViewBaseParameters<TPlugins> & MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'defaultizedParams'>;
 export interface UseTreeViewRootSlotProps extends Pick<React.HTMLAttributes<HTMLUListElement>, 'onFocus' | 'onBlur' | 'onKeyDown' | 'id' | 'aria-multiselectable' | 'role' | 'tabIndex'> {
     ref: React.Ref<HTMLUListElement>;
 }
-export interface UseTreeViewReturnValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
+export interface UseTreeViewReturnValue<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
     getRootProps: <TOther extends EventHandlers = {}>(otherHandlers?: TOther) => UseTreeViewRootSlotProps;
     rootRef: React.RefCallback<HTMLUListElement> | null;
-    contextValue: TreeViewContextValue<TPlugins>;
-    instance: TreeViewInstance<TPlugins>;
+    contextValue: TreeViewContextValue<TSignatures>;
+    instance: TreeViewInstance<TSignatures>;
 }

package/internals/useTreeView/useTreeViewModels.d.ts

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

package/internals/utils/publishTreeViewEvent.d.ts

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

package/internals/utils/utils.d.ts

@@ -1 +1,2 @@
 export declare const getActiveElement: (root?: Document | ShadowRoot) => Element | null;
+export declare function escapeOperandAttributeSelector(operand: string): string;

package/internals/utils/utils.js

@@ -8,4 +8,10 @@ export const getActiveElement = (root = document) => {
     return getActiveElement(activeEl.shadowRoot);
   }
   return activeEl;
-};
+};
+
+// TODO, eventually replaces this function with CSS.escape, once available in jsdom, either added manually or built in
+// https://github.com/jsdom/jsdom/issues/1550#issuecomment-236734471
+export function escapeOperandAttributeSelector(operand) {
+  return operand.replace(/["\\]/g, '\\$&');
+}

package/internals/zero-styled/index.d.ts

@@ -0,0 +1,3 @@
+import { useThemeProps } from '@mui/material/styles';
+export { styled } from '@mui/material/styles';
+export declare function createUseThemeProps(name: string): typeof useThemeProps;

package/internals/zero-styled/index.js

@@ -0,0 +1,7 @@
+import { useThemeProps } from '@mui/material/styles';
+export { styled } from '@mui/material/styles';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function createUseThemeProps(name) {
+  return useThemeProps;
+}

package/modern/RichTreeView/RichTreeView.js

@@ -1,17 +1,17 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import { styled, useThemeProps } from '@mui/material/styles';
 import composeClasses from '@mui/utils/composeClasses';
 import { useSlotProps } from '@mui/base/utils';
 import { getRichTreeViewUtilityClass } from './richTreeViewClasses';
+import { styled, createUseThemeProps } from '../internals/zero-styled';
 import { useTreeView } from '../internals/useTreeView';
 import { TreeViewProvider } from '../internals/TreeViewProvider';
-import { DEFAULT_TREE_VIEW_PLUGINS } from '../internals/plugins';
+import { RICH_TREE_VIEW_PLUGINS } from './RichTreeView.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 useThemeProps = createUseThemeProps('MuiRichTreeView');
 const useUtilityClasses = ownerState => {
   const {
     classes
@@ -80,27 +80,24 @@ const RichTreeView = /*#__PURE__*/React.forwardRef(function RichTreeView(inProps
       childrenWarning();
     }
   }
-  const {
-    pluginParams,
-    slots,
-    slotProps,
-    otherProps
-  } = extractPluginParamsFromProps({
-    props,
-    plugins: DEFAULT_TREE_VIEW_PLUGINS,
-    rootRef: ref
-  });
   const {
     getRootProps,
     contextValue,
     instance
-  } = useTreeView(pluginParams);
+  } = useTreeView({
+    plugins: RICH_TREE_VIEW_PLUGINS,
+    rootRef: ref,
+    props
+  });
+  const {
+    slots,
+    slotProps
+  } = props;
   const classes = useUtilityClasses(props);
   const Root = slots?.root ?? RichTreeViewRoot;
   const rootProps = useSlotProps({
     elementType: Root,
     externalSlotProps: slotProps?.root,
-    externalForwardedProps: otherProps,
     className: classes.root,
     getSlotProps: getRootProps,
     ownerState: props

package/modern/RichTreeView/RichTreeView.plugins.js

@@ -0,0 +1,9 @@
+import { useTreeViewItems } from '../internals/plugins/useTreeViewItems';
+import { useTreeViewExpansion } from '../internals/plugins/useTreeViewExpansion';
+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];
+
+// We can't infer this type from the plugin, otherwise we would lose the generics.

package/modern/RichTreeView/index.js

@@ -1,3 +1,3 @@
 export * from './RichTreeView';
 export * from './richTreeViewClasses';
-export {};
+export { RICH_TREE_VIEW_PLUGINS } from './RichTreeView.plugins';

package/modern/SimpleTreeView/SimpleTreeView.js

@@ -1,16 +1,16 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import { styled, useThemeProps } from '@mui/material/styles';
 import composeClasses from '@mui/utils/composeClasses';
 import { useSlotProps } from '@mui/base/utils';
+import { styled, createUseThemeProps } from '../internals/zero-styled';
 import { getSimpleTreeViewUtilityClass } from './simpleTreeViewClasses';
 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 useThemeProps = createUseThemeProps('MuiSimpleTreeView');
 const useUtilityClasses = ownerState => {
   const {
     classes
@@ -56,27 +56,24 @@ const SimpleTreeView = /*#__PURE__*/React.forwardRef(function SimpleTreeView(inP
     }
   }
   const {
-    pluginParams,
-    slots,
-    slotProps,
-    otherProps
-  } = extractPluginParamsFromProps({
+    getRootProps,
+    contextValue
+  } = useTreeView({
+    plugins: SIMPLE_TREE_VIEW_PLUGINS,
+    rootRef: ref,
     props: _extends({}, props, {
       items: EMPTY_ITEMS
-    }),
-    plugins: SIMPLE_TREE_VIEW_PLUGINS,
-    rootRef: ref
+    })
   });
   const {
-    getRootProps,
-    contextValue
-  } = useTreeView(pluginParams);
+    slots,
+    slotProps
+  } = props;
   const classes = useUtilityClasses(props);
   const Root = slots?.root ?? SimpleTreeViewRoot;
   const rootProps = useSlotProps({
     elementType: Root,
     externalSlotProps: slotProps?.root,
-    externalForwardedProps: otherProps,
     className: classes.root,
     getSlotProps: getRootProps,
     ownerState

package/modern/SimpleTreeView/SimpleTreeView.plugins.js

@@ -1,5 +1,10 @@
-import { DEFAULT_TREE_VIEW_PLUGINS } from '../internals/plugins/defaultPlugins';
+import { useTreeViewItems } from '../internals/plugins/useTreeViewItems';
+import { useTreeViewExpansion } from '../internals/plugins/useTreeViewExpansion';
+import { useTreeViewSelection } from '../internals/plugins/useTreeViewSelection';
+import { useTreeViewFocus } from '../internals/plugins/useTreeViewFocus';
+import { useTreeViewKeyboardNavigation } from '../internals/plugins/useTreeViewKeyboardNavigation';
+import { useTreeViewIcons } from '../internals/plugins/useTreeViewIcons';
 import { useTreeViewJSXItems } from '../internals/plugins/useTreeViewJSXItems';
-export const SIMPLE_TREE_VIEW_PLUGINS = [...DEFAULT_TREE_VIEW_PLUGINS, useTreeViewJSXItems];
+export const SIMPLE_TREE_VIEW_PLUGINS = [useTreeViewItems, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewIcons, useTreeViewJSXItems];
 
 // We can't infer this type from the plugin, otherwise we would lose the generics.

package/modern/TreeItem/TreeItem.js

@@ -11,10 +11,11 @@ import Collapse from '@mui/material/Collapse';
 import { resolveComponentProps, useSlotProps } from '@mui/base/utils';
 import useForkRef from '@mui/utils/useForkRef';
 import { shouldForwardProp } from '@mui/system/createStyled';
-import { alpha, styled, useThemeProps } from '@mui/material/styles';
+import { alpha } from '@mui/material/styles';
 import unsupportedProp from '@mui/utils/unsupportedProp';
 import elementTypeAcceptingRef from '@mui/utils/elementTypeAcceptingRef';
 import { unstable_composeClasses as composeClasses } from '@mui/base';
+import { styled, createUseThemeProps } from '../internals/zero-styled';
 import { TreeItemContent } from './TreeItemContent';
 import { treeItemClasses, getTreeItemUtilityClass } from './treeItemClasses';
 import { useTreeViewContext } from '../internals/TreeViewProvider/useTreeViewContext';
@@ -22,6 +23,7 @@ import { TreeViewCollapseIcon, TreeViewExpandIcon } from '../icons';
 import { TreeItem2Provider } from '../TreeItem2Provider';
 import { TreeViewItemDepthContext } from '../internals/TreeViewItemDepthContext';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const useThemeProps = createUseThemeProps('MuiTreeItem');
 const useUtilityClasses = ownerState => {
   const {
     classes
@@ -390,6 +392,10 @@ process.env.NODE_ENV !== "production" ? TreeItem.propTypes = {
    * Use the `onItemFocus` callback on the tree if you need to monitor a item's focus.
    */
   onFocus: unsupportedProp,
+  /**
+   * Callback fired when a key of the keyboard is pressed on the item.
+   */
+  onKeyDown: PropTypes.func,
   /**
    * The props used for each component slot.
    * @default {}

package/modern/TreeItem2/TreeItem2.js

@@ -6,17 +6,19 @@ import * as React from 'react';
 import PropTypes from 'prop-types';
 import clsx from 'clsx';
 import unsupportedProp from '@mui/utils/unsupportedProp';
-import { alpha, styled, useThemeProps } from '@mui/material/styles';
+import { alpha } from '@mui/material/styles';
 import Collapse from '@mui/material/Collapse';
 import MuiCheckbox from '@mui/material/Checkbox';
 import { useSlotProps } from '@mui/base/utils';
 import { shouldForwardProp } from '@mui/system/createStyled';
 import composeClasses from '@mui/utils/composeClasses';
+import { styled, createUseThemeProps } from '../internals/zero-styled';
 import { unstable_useTreeItem2 as useTreeItem2 } from '../useTreeItem2';
 import { getTreeItemUtilityClass } from '../TreeItem';
 import { TreeItem2Icon } from '../TreeItem2Icon';
 import { TreeItem2Provider } from '../TreeItem2Provider';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const useThemeProps = createUseThemeProps('MuiTreeItem2');
 export const TreeItem2Root = styled('li', {
   name: 'MuiTreeItem2',
   slot: 'Root',
@@ -321,11 +323,19 @@ process.env.NODE_ENV !== "production" ? TreeItem2.propTypes = {
    * The label of the item.
    */
   label: PropTypes.node,
+  /**
+   * Callback fired when the item root is blurred.
+   */
+  onBlur: PropTypes.func,
   /**
    * This prop isn't supported.
-   * Use the `onItemFocus` callback on the tree if you need to monitor a item's focus.
+   * Use the `onItemFocus` callback on the tree if you need to monitor an item's focus.
    */
   onFocus: unsupportedProp,
+  /**
+   * Callback fired when a key is pressed on the keyboard and the tree is in focus.
+   */
+  onKeyDown: PropTypes.func,
   /**
    * The props used for each component slot.
    * @default {}

package/modern/TreeView/TreeView.js

@@ -1,11 +1,12 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import { styled, useThemeProps } from '@mui/material/styles';
 import composeClasses from '@mui/utils/composeClasses';
+import { styled, createUseThemeProps } from '../internals/zero-styled';
 import { getTreeViewUtilityClass } from './treeViewClasses';
 import { SimpleTreeView, SimpleTreeViewRoot } from '../SimpleTreeView';
 import { jsx as _jsx } from "react/jsx-runtime";
+const useThemeProps = createUseThemeProps('MuiTreeView');
 const useUtilityClasses = ownerState => {
   const {
     classes

package/modern/hooks/useTreeItem2Utils/useTreeItem2Utils.js

@@ -5,6 +5,15 @@ const isItemExpandable = reactChildren => {
   }
   return Boolean(reactChildren);
 };
+
+/**
+ * Plugins that need to be present in the Tree View in order for `useTreeItem2Utils` to work correctly.
+ */
+
+/**
+ * Plugins that `useTreeItem2Utils` can use if they are present, but are not required.
+ */
+
 export const useTreeItem2Utils = ({
   itemId,
   children

package/modern/index.js

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

package/modern/internals/TreeViewProvider/TreeViewChildrenItemProvider.js

@@ -1,6 +1,7 @@
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { useTreeViewContext } from './useTreeViewContext';
+import { escapeOperandAttributeSelector } from '../utils/utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 export const TreeViewChildrenItemContext = /*#__PURE__*/React.createContext(null);
 if (process.env.NODE_ENV !== 'production') {
@@ -34,7 +35,8 @@ export function TreeViewChildrenItemProvider(props) {
       return;
     }
     const previousChildrenIds = instance.getItemOrderedChildrenIds(itemId ?? null) ?? [];
-    const childrenElements = rootRef.current.querySelectorAll(`${itemId == null ? '' : `*[id="${idAttr}"] `}[role="treeitem"]:not(*[id="${idAttr}"] [role="treeitem"] [role="treeitem"])`);
+    const escapedIdAttr = escapeOperandAttributeSelector(idAttr);
+    const childrenElements = rootRef.current.querySelectorAll(`${itemId == null ? '' : `*[id="${escapedIdAttr}"] `}[role="treeitem"]:not(*[id="${escapedIdAttr}"] [role="treeitem"] [role="treeitem"])`);
     const childrenIds = Array.from(childrenElements).map(child => childrenIdAttrToIdRef.current.get(child.id));
     const hasChanged = childrenIds.length !== previousChildrenIds.length || childrenIds.some((childId, index) => childId !== previousChildrenIds[index]);
     if (hasChanged) {

package/modern/internals/corePlugins/corePlugins.js

@@ -1,6 +1,7 @@
 import { useTreeViewInstanceEvents } from './useTreeViewInstanceEvents';
+import { useTreeViewId } from './useTreeViewId';
 /**
  * Internal plugins that create the tools used by the other plugins.
  * These plugins are used by the tree view components.
  */
-export const TREE_VIEW_CORE_PLUGINS = [useTreeViewInstanceEvents];
+export const TREE_VIEW_CORE_PLUGINS = [useTreeViewInstanceEvents, useTreeViewId];

package/modern/internals/index.js

@@ -1,15 +1,15 @@
 export { useTreeView } from './useTreeView';
 export { TreeViewProvider } from './TreeViewProvider';
 export { unstable_resetCleanupTracking } from './hooks/useInstanceEventHandler';
+
+// Core plugins
+
 // Plugins
-export { DEFAULT_TREE_VIEW_PLUGINS } from './plugins/defaultPlugins';
 export { useTreeViewExpansion } from './plugins/useTreeViewExpansion';
 export { useTreeViewSelection } from './plugins/useTreeViewSelection';
 export { useTreeViewFocus } from './plugins/useTreeViewFocus';
 export { useTreeViewKeyboardNavigation } from './plugins/useTreeViewKeyboardNavigation';
-export { useTreeViewId } from './plugins/useTreeViewId';
 export { useTreeViewIcons } from './plugins/useTreeViewIcons';
 export { useTreeViewItems } from './plugins/useTreeViewItems';
 export { useTreeViewJSXItems } from './plugins/useTreeViewJSXItems';
-export { buildWarning } from './utils/warning';
-export { extractPluginParamsFromProps } from './utils/extractPluginParamsFromProps';
+export { buildWarning } from './utils/warning';

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

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { useTheme } from '@mui/material/styles';
+import { useRtl } from '@mui/system/RtlProvider';
 import useEventCallback from '@mui/utils/useEventCallback';
 import { getFirstNavigableItem, getLastNavigableItem, getNextNavigableItem, getPreviousNavigableItem } from '../../utils/tree';
 function isPrintableCharacter(string) {
@@ -10,8 +10,7 @@ export const useTreeViewKeyboardNavigation = ({
   params,
   state
 }) => {
-  const theme = useTheme();
-  const isRTL = theme.direction === 'rtl';
+  const isRtl = useRtl();
   const firstCharMap = React.useRef({});
   const updateFirstCharMap = useEventCallback(callback => {
     firstCharMap.current = callback(firstCharMap.current);
@@ -138,7 +137,7 @@ export const useTreeViewKeyboardNavigation = ({
 
       // 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:
+      case key === 'ArrowRight' && !isRtl || key === 'ArrowLeft' && isRtl:
         {
           if (instance.isItemExpanded(itemId)) {
             const nextItemId = getNextNavigableItem(instance, itemId);
@@ -155,7 +154,7 @@ export const useTreeViewKeyboardNavigation = ({
 
       // 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:
+      case key === 'ArrowLeft' && !isRtl || key === 'ArrowRight' && isRtl:
         {
           if (canToggleItemExpansion(itemId) && instance.isItemExpanded(itemId)) {
             instance.toggleItemExpansion(event, itemId);