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

package/legacy/SimpleTreeView/SimpleTreeView.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-var _excluded = ["disabledItemsFocusable", "expandedNodes", "defaultExpandedNodes", "onExpandedNodesChange", "onNodeExpansionToggle", "onNodeFocus", "disableSelection", "defaultSelectedNodes", "selectedNodes", "multiSelect", "onSelectedNodesChange", "onNodeSelectionToggle", "id", "defaultCollapseIcon", "defaultEndIcon", "defaultExpandIcon", "defaultParentIcon", "children", "slots", "slotProps"];
+var _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";
 var useUtilityClasses = function useUtilityClasses(ownerState) {
   var classes = ownerState.classes;
@@ -32,7 +33,7 @@ export var SimpleTreeViewRoot = styled('ul', {
   outline: 0
 });
 var EMPTY_ITEMS = [];
-var 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/']);
+var 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/']);
 
 /**
  *
@@ -51,55 +52,24 @@ var SimpleTreeView = /*#__PURE__*/React.forwardRef(function SimpleTreeView(inPro
     name: 'MuiSimpleTreeView'
   });
   var ownerState = props;
-  var _ref = props,
-    disabledItemsFocusable = _ref.disabledItemsFocusable,
-    expandedNodes = _ref.expandedNodes,
-    defaultExpandedNodes = _ref.defaultExpandedNodes,
-    onExpandedNodesChange = _ref.onExpandedNodesChange,
-    onNodeExpansionToggle = _ref.onNodeExpansionToggle,
-    onNodeFocus = _ref.onNodeFocus,
-    disableSelection = _ref.disableSelection,
-    defaultSelectedNodes = _ref.defaultSelectedNodes,
-    selectedNodes = _ref.selectedNodes,
-    multiSelect = _ref.multiSelect,
-    onSelectedNodesChange = _ref.onSelectedNodesChange,
-    onNodeSelectionToggle = _ref.onNodeSelectionToggle,
-    id = _ref.id,
-    defaultCollapseIcon = _ref.defaultCollapseIcon,
-    defaultEndIcon = _ref.defaultEndIcon,
-    defaultExpandIcon = _ref.defaultExpandIcon,
-    defaultParentIcon = _ref.defaultParentIcon,
-    children = _ref.children,
-    slots = _ref.slots,
-    slotProps = _ref.slotProps,
-    other = _objectWithoutProperties(_ref, _excluded);
   if (process.env.NODE_ENV !== 'production') {
     if (props.items != null) {
       itemsPropWarning();
     }
   }
-  var _useTreeView = useTreeView({
-      disabledItemsFocusable: disabledItemsFocusable,
-      expandedNodes: expandedNodes,
-      defaultExpandedNodes: defaultExpandedNodes,
-      onExpandedNodesChange: onExpandedNodesChange,
-      onNodeExpansionToggle: onNodeExpansionToggle,
-      onNodeFocus: onNodeFocus,
-      disableSelection: disableSelection,
-      defaultSelectedNodes: defaultSelectedNodes,
-      selectedNodes: selectedNodes,
-      multiSelect: multiSelect,
-      onSelectedNodesChange: onSelectedNodesChange,
-      onNodeSelectionToggle: onNodeSelectionToggle,
-      id: id,
-      defaultCollapseIcon: defaultCollapseIcon,
-      defaultEndIcon: defaultEndIcon,
-      defaultExpandIcon: defaultExpandIcon,
-      defaultParentIcon: defaultParentIcon,
-      items: EMPTY_ITEMS,
+  var _extractPluginParamsF = extractPluginParamsFromProps({
+      props: _extends({}, props, {
+        items: EMPTY_ITEMS
+      }),
       plugins: SIMPLE_TREE_VIEW_PLUGINS,
       rootRef: ref
     }),
+    pluginParams = _extractPluginParamsF.pluginParams,
+    _extractPluginParamsF2 = _extractPluginParamsF.otherProps,
+    slots = _extractPluginParamsF2.slots,
+    slotProps = _extractPluginParamsF2.slotProps,
+    otherProps = _objectWithoutProperties(_extractPluginParamsF2, _excluded);
+  var _useTreeView = useTreeView(pluginParams),
     getRootProps = _useTreeView.getRootProps,
     contextValue = _useTreeView.contextValue;
   var classes = useUtilityClasses(props);
@@ -107,16 +77,14 @@ var SimpleTreeView = /*#__PURE__*/React.forwardRef(function SimpleTreeView(inPro
   var rootProps = useSlotProps({
     elementType: Root,
     externalSlotProps: {},
-    externalForwardedProps: other,
+    externalForwardedProps: otherProps,
     className: classes.root,
     getSlotProps: getRootProps,
     ownerState: 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/legacy/TreeView/TreeView.js

@@ -23,7 +23,7 @@ var TreeViewRoot = styled(SimpleTreeViewRoot, {
 var warnedOnce = false;
 var warn = function 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/legacy/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/legacy/internals/TreeViewProvider/useTreeViewContext.js

@@ -3,7 +3,7 @@ import { TreeViewContext } from './TreeViewContext';
 export var useTreeViewContext = function useTreeViewContext() {
   var 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/legacy/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.js

@@ -36,4 +36,5 @@ export var useTreeViewInstanceEvents = function useTreeViewInstanceEvents(_ref)
     $$publishEvent: publishEvent,
     $$subscribeEvent: subscribeEvent
   });
-};
+};
+useTreeViewInstanceEvents.params = {};

package/legacy/internals/models/MuiCancellableEvent.js

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

package/legacy/internals/plugins/useTreeViewContextValueBuilder/useTreeViewContextValueBuilder.js

@@ -25,4 +25,10 @@ export var useTreeViewContextValueBuilder = function useTreeViewContextValueBuil
       }
     }
   };
+};
+useTreeViewContextValueBuilder.params = {
+  defaultCollapseIcon: true,
+  defaultEndIcon: true,
+  defaultExpandIcon: true,
+  defaultParentIcon: true
 };

package/legacy/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -72,4 +72,10 @@ useTreeViewExpansion.getDefaultizedParams = function (params) {
   return _extends({}, params, {
     defaultExpandedNodes: (_params$defaultExpand = params.defaultExpandedNodes) != null ? _params$defaultExpand : DEFAULT_EXPANDED_NODES
   });
+};
+useTreeViewExpansion.params = {
+  expandedNodes: true,
+  defaultExpandedNodes: true,
+  onExpandedNodesChange: true,
+  onNodeExpansionToggle: true
 };

package/legacy/internals/plugins/useTreeViewFocus/useTreeViewFocus.js

@@ -103,4 +103,7 @@ useTreeViewFocus.getDefaultizedParams = function (params) {
   return _extends({}, params, {
     disabledItemsFocusable: (_params$disabledItems = params.disabledItemsFocusable) != null ? _params$disabledItems : false
   });
+};
+useTreeViewFocus.params = {
+  onNodeFocus: true
 };

package/legacy/internals/plugins/useTreeViewId/useTreeViewId.js

@@ -18,4 +18,7 @@ export var useTreeViewId = function useTreeViewId(_ref) {
       };
     }
   };
+};
+useTreeViewId.params = {
+  id: true
 };

package/legacy/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.js

@@ -117,4 +117,5 @@ var useTreeViewJSXNodesItemPlugin = function useTreeViewJSXNodesItemPlugin(_ref2
     }
   };
 };
-useTreeViewJSXNodes.itemPlugin = useTreeViewJSXNodesItemPlugin;
+useTreeViewJSXNodes.itemPlugin = useTreeViewJSXNodesItemPlugin;
+useTreeViewJSXNodes.params = {};

package/legacy/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 (var i = startIndex; i < firstChars.length; i += 1) {
@@ -18,7 +18,7 @@ export var useTreeViewKeyboardNavigation = function useTreeViewKeyboardNavigatio
     params = _ref.params,
     state = _ref.state;
   var theme = useTheme();
-  var isRtl = theme.direction === 'rtl';
+  var isRTL = theme.direction === 'rtl';
   var firstCharMap = React.useRef({});
   var hasFirstCharMapBeenUpdatedImperatively = React.useRef(false);
   var updateFirstCharMap = useEventCallback(function (callback) {
@@ -43,32 +43,7 @@ export var useTreeViewKeyboardNavigation = function useTreeViewKeyboardNavigatio
   populateInstance(instance, {
     updateFirstCharMap: updateFirstCharMap
   });
-  var handleNextArrow = function 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;
-  };
-  var handlePreviousArrow = function handlePreviousArrow(event) {
-    if (state.focusedNodeId == null) {
-      return false;
-    }
-    if (instance.isNodeExpanded(state.focusedNodeId) && !instance.isNodeDisabled(state.focusedNodeId)) {
-      instance.toggleNodeExpansion(event, state.focusedNodeId);
-      return true;
-    }
-    var parent = instance.getNode(state.focusedNodeId).parentId;
-    if (parent) {
-      instance.focusNode(event, parent);
-      return true;
-    }
-    return false;
-  };
-  var focusByFirstCharacter = function focusByFirstCharacter(event, nodeId, firstChar) {
+  var getFirstMatchingNode = function getFirstMatchingNode(nodeId, firstChar) {
     var start;
     var index;
     var lowercaseChar = firstChar.toLowerCase();
@@ -99,43 +74,41 @@ export var useTreeViewKeyboardNavigation = function useTreeViewKeyboardNavigatio
       index = findNextFirstChar(firstChars, 0, lowercaseChar);
     }
 
-    // If match was found...
+    // If a match was found...
     if (index > -1) {
-      instance.focusNode(event, firstCharIds[index]);
+      return firstCharIds[index];
     }
+    return null;
   };
-  var selectNextNode = function selectNextNode(event, id) {
-    if (!instance.isNodeDisabled(getNextNode(instance, id))) {
-      instance.selectRange(event, {
-        end: getNextNode(instance, id),
-        current: id
-      }, true);
-    }
+  var canToggleNodeSelection = function canToggleNodeSelection(nodeId) {
+    return !params.disableSelection && !instance.isNodeDisabled(nodeId);
   };
-  var selectPreviousNode = function selectPreviousNode(event, nodeId) {
-    if (!instance.isNodeDisabled(getPreviousNode(instance, nodeId))) {
-      instance.selectRange(event, {
-        end: getPreviousNode(instance, nodeId),
-        current: nodeId
-      }, true);
-    }
+  var canToggleNodeExpansion = function canToggleNodeExpansion(nodeId) {
+    return !instance.isNodeDisabled(nodeId) && instance.isNodeExpandable(nodeId);
   };
+
+  // ARIA specification: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/#keyboardinteraction
   var createHandleKeyDown = function createHandleKeyDown(otherHandlers) {
     return function (event) {
       var _otherHandlers$onKeyD;
       (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);
-      var flag = false;
-      var 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;
       }
       var ctrlPressed = event.ctrlKey || event.metaKey;
-      switch (key) {
-        case ' ':
-          if (!params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-            flag = true;
+      var 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
@@ -145,85 +118,158 @@ export var useTreeViewKeyboardNavigation = function useTreeViewKeyboardNavigatio
             } 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':
+          {
+            var 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':
+          {
+            var 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 {
+              var 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):
+          {
+            var matchingNode = getFirstMatchingNode(state.focusedNodeId, key);
+            if (matchingNode != null) {
+              instance.focusNode(event, matchingNode);
+              event.preventDefault();
+            }
+            break;
           }
-      }
-      if (flag) {
-        event.preventDefault();
-        event.stopPropagation();
       }
     };
   };
@@ -234,4 +280,5 @@ export var useTreeViewKeyboardNavigation = function useTreeViewKeyboardNavigatio
       };
     }
   };
-};
+};
+useTreeViewKeyboardNavigation.params = {};

package/legacy/internals/plugins/useTreeViewNodes/useTreeViewNodes.js

@@ -13,11 +13,11 @@ var updateState = function updateState(_ref) {
     var _item$children, _item$children2;
     var id = getItemId ? getItemId(item) : item.id;
     if (id == null) {
-      throw new Error(['MUI: The Tree View component requires all items to have a unique `id` property.', 'Alternatively, you can use the `getItemId` prop to specify a custom id for each item.', 'An item was provided without id in the `items` prop:', JSON.stringify(item)].join('\n'));
+      throw new Error(['MUI X: The Tree View component requires all items to have a unique `id` property.', 'Alternatively, you can use the `getItemId` prop to specify a custom id for each item.', 'An item was provided without id in the `items` prop:', JSON.stringify(item)].join('\n'));
     }
     var label = getItemLabel ? getItemLabel(item) : item.label;
     if (label == null) {
-      throw new Error(['MUI: The Tree View component requires all items to have a `label` property.', 'Alternatively, you can use the `getItemLabel` prop to specify a custom label for each item.', 'An item was provided without label in the `items` prop:', JSON.stringify(item)].join('\n'));
+      throw new Error(['MUI X: The Tree View component requires all items to have a `label` property.', 'Alternatively, you can use the `getItemLabel` prop to specify a custom label for each item.', 'An item was provided without label in the `items` prop:', JSON.stringify(item)].join('\n'));
     }
     nodeMap[id] = {
       id: id,
@@ -137,4 +137,11 @@ useTreeViewNodes.getInitialState = function (params) {
     getItemId: params.getItemId,
     getItemLabel: params.getItemLabel
   });
+};
+useTreeViewNodes.params = {
+  disabledItemsFocusable: true,
+  items: true,
+  isItemDisabled: true,
+  getItemLabel: true,
+  getItemId: true
 };

package/legacy/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -202,4 +202,12 @@ useTreeViewSelection.getDefaultizedParams = function (params) {
     multiSelect: (_params$multiSelect = params.multiSelect) != null ? _params$multiSelect : false,
     defaultSelectedNodes: (_params$defaultSelect = params.defaultSelectedNodes) != null ? _params$defaultSelect : params.multiSelect ? DEFAULT_SELECTED_NODES : null
   });
+};
+useTreeViewSelection.params = {
+  disableSelection: true,
+  multiSelect: true,
+  defaultSelectedNodes: true,
+  selectedNodes: true,
+  onSelectedNodesChange: true,
+  onNodeSelectionToggle: true
 };

package/legacy/internals/useTreeView/useTreeViewModels.js

@@ -58,14 +58,14 @@ export var useTreeViewModels = function useTreeViewModels(plugins, props) {
       var defaultProp = props[model.defaultProp];
       React.useEffect(function () {
         if (model.isControlled !== (controlled !== undefined)) {
-          console.error(["MUI: A component is changing the ".concat(model.isControlled ? '' : 'un', "controlled ").concat(modelName, " state of TreeView to be ").concat(model.isControlled ? 'un' : '', "controlled."), 'Elements should not switch from uncontrolled to controlled (or vice versa).', "Decide between using a controlled or uncontrolled ".concat(modelName, " ") + 'element for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
+          console.error(["MUI X: A component is changing the ".concat(model.isControlled ? '' : 'un', "controlled ").concat(modelName, " state of TreeView to be ").concat(model.isControlled ? 'un' : '', "controlled."), 'Elements should not switch from uncontrolled to controlled (or vice versa).', "Decide between using a controlled or uncontrolled ".concat(modelName, " ") + 'element for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
         }
       }, [controlled]);
       var _React$useRef = React.useRef(defaultProp),
         defaultValue = _React$useRef.current;
       React.useEffect(function () {
         if (!model.isControlled && defaultValue !== defaultProp) {
-          console.error(["MUI: A component is changing the default ".concat(modelName, " state of an uncontrolled TreeView after being initialized. ") + "To suppress this warning opt to use a controlled TreeView."].join('\n'));
+          console.error(["MUI X: A component is changing the default ".concat(modelName, " state of an uncontrolled TreeView after being initialized. ") + "To suppress this warning opt to use a controlled TreeView."].join('\n'));
         }
       }, [JSON.stringify(defaultValue)]);
     });

package/legacy/internals/utils/extractPluginParamsFromProps.js

@@ -0,0 +1,27 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+export var extractPluginParamsFromProps = function extractPluginParamsFromProps(_ref) {
+  var props = _ref.props,
+    plugins = _ref.plugins,
+    rootRef = _ref.rootRef;
+  var paramsLookup = {};
+  plugins.forEach(function (plugin) {
+    _extends(paramsLookup, plugin.params);
+  });
+  var pluginParams = {
+    plugins: plugins,
+    rootRef: rootRef
+  };
+  var otherProps = {};
+  Object.keys(props).forEach(function (propName) {
+    var prop = props[propName];
+    if (paramsLookup[propName]) {
+      pluginParams[propName] = prop;
+    } else {
+      otherProps[propName] = prop;
+    }
+  });
+  return {
+    pluginParams: pluginParams,
+    otherProps: otherProps
+  };
+};