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

package/internals/plugins/useTreeViewIcons/useTreeViewIcons.js

@@ -0,0 +1,22 @@
+export const useTreeViewIcons = ({
+  slots,
+  slotProps
+}) => {
+  return {
+    contextValue: {
+      icons: {
+        slots: {
+          collapseIcon: slots.collapseIcon,
+          expandIcon: slots.expandIcon,
+          endIcon: slots.endIcon
+        },
+        slotProps: {
+          collapseIcon: slotProps.collapseIcon,
+          expandIcon: slotProps.expandIcon,
+          endIcon: slotProps.endIcon
+        }
+      }
+    }
+  };
+};
+useTreeViewIcons.params = {};

package/internals/plugins/useTreeViewIcons/useTreeViewIcons.types.d.ts

@@ -0,0 +1,43 @@
+import * as React from 'react';
+import { SlotComponentProps } from '@mui/base/utils';
+import { TreeViewPluginSignature } from '../../models';
+import { UseTreeViewNodesSignature } from '../useTreeViewNodes';
+import { UseTreeViewSelectionSignature } from '../useTreeViewSelection';
+export interface UseTreeViewIconsParameters {
+}
+export type UseTreeViewIconsDefaultizedParameters = UseTreeViewIconsParameters;
+interface UseTreeViewIconsSlots {
+    /**
+     * The default icon used to collapse the node.
+     */
+    collapseIcon?: React.ElementType;
+    /**
+     * The default icon used to expand the node.
+     */
+    expandIcon?: React.ElementType;
+    /**
+     * The default icon displayed next to an end node.
+     * This is applied to all tree nodes and can be overridden by the TreeItem `icon` slot prop.
+     */
+    endIcon?: React.ElementType;
+}
+interface UseTreeViewIconsSlotProps {
+    collapseIcon?: SlotComponentProps<'svg', {}, {}>;
+    expandIcon?: SlotComponentProps<'svg', {}, {}>;
+    endIcon?: SlotComponentProps<'svg', {}, {}>;
+}
+interface UseTreeViewIconsContextValue {
+    icons: {
+        slots: UseTreeViewIconsSlots;
+        slotProps: UseTreeViewIconsSlotProps;
+    };
+}
+export type UseTreeViewIconsSignature = TreeViewPluginSignature<{
+    params: UseTreeViewIconsParameters;
+    defaultizedParams: UseTreeViewIconsDefaultizedParameters;
+    contextValue: UseTreeViewIconsContextValue;
+    slots: UseTreeViewIconsSlots;
+    slotProps: UseTreeViewIconsSlotProps;
+    dependantPlugins: [UseTreeViewNodesSignature, UseTreeViewSelectionSignature];
+}>;
+export {};

package/internals/plugins/useTreeViewId/useTreeViewId.js

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

package/internals/plugins/useTreeViewId/useTreeViewId.types.d.ts

@@ -13,5 +13,9 @@ export type UseTreeViewIdDefaultizedParameters = UseTreeViewIdParameters;
 export interface UseTreeViewIdState {
     focusedNodeId: string | null;
 }
-export type UseTreeViewIdSignature = TreeViewPluginSignature<UseTreeViewIdParameters, UseTreeViewIdDefaultizedParameters, UseTreeViewIdInstance, {}, UseTreeViewIdState, never, [
-]>;
+export type UseTreeViewIdSignature = TreeViewPluginSignature<{
+    params: UseTreeViewIdParameters;
+    defaultizedParams: UseTreeViewIdDefaultizedParameters;
+    instance: UseTreeViewIdInstance;
+    state: UseTreeViewIdState;
+}>;

package/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.js

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

package/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.types.d.ts

@@ -10,7 +10,9 @@ export interface UseTreeViewNodesParameters {
 }
 export interface UseTreeViewNodesDefaultizedParameters {
 }
-export type UseTreeViewJSXNodesSignature = TreeViewPluginSignature<UseTreeViewNodesParameters, UseTreeViewNodesDefaultizedParameters, UseTreeViewNodesInstance, {}, {}, never, [
-    UseTreeViewNodesSignature,
-    UseTreeViewKeyboardNavigationSignature
-]>;
+export type UseTreeViewJSXNodesSignature = TreeViewPluginSignature<{
+    params: UseTreeViewNodesParameters;
+    defaultizedParams: UseTreeViewNodesDefaultizedParameters;
+    instance: UseTreeViewNodesInstance;
+    dependantPlugins: [UseTreeViewNodesSignature, UseTreeViewKeyboardNavigationSignature];
+}>;

package/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 => {
@@ -44,32 +44,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();
@@ -100,42 +75,36 @@ 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 => {
     var _otherHandlers$onKeyD;
     (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, 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
@@ -145,85 +114,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 {
@@ -231,4 +273,5 @@ export const useTreeViewKeyboardNavigation = ({
       onKeyDown: createHandleKeyDown(otherHandlers)
     })
   };
-};
+};
+useTreeViewKeyboardNavigation.params = {};

package/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.types.d.ts

@@ -6,12 +6,15 @@ import { UseTreeViewExpansionSignature } from '../useTreeViewExpansion';
 export interface UseTreeViewKeyboardNavigationInstance {
     updateFirstCharMap: (updater: (map: TreeViewFirstCharMap) => TreeViewFirstCharMap) => void;
 }
-export type UseTreeViewKeyboardNavigationSignature = TreeViewPluginSignature<{}, {}, UseTreeViewKeyboardNavigationInstance, {}, {}, never, [
-    UseTreeViewNodesSignature,
-    UseTreeViewSelectionSignature,
-    UseTreeViewFocusSignature,
-    UseTreeViewExpansionSignature
-]>;
+export type UseTreeViewKeyboardNavigationSignature = TreeViewPluginSignature<{
+    instance: UseTreeViewKeyboardNavigationInstance;
+    dependantPlugins: [
+        UseTreeViewNodesSignature,
+        UseTreeViewSelectionSignature,
+        UseTreeViewFocusSignature,
+        UseTreeViewExpansionSignature
+    ];
+}>;
 export type TreeViewFirstCharMap = {
     [nodeId: string]: string;
 };

package/internals/plugins/useTreeViewNodes/useTreeViewNodes.js

@@ -14,11 +14,11 @@ const updateState = ({
     var _item$children, _item$children2;
     const 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'));
     }
     const 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,
@@ -116,10 +116,28 @@ export const useTreeViewNodes = ({
     getNavigableChildrenIds,
     isNodeDisabled
   });
+  return {
+    contextValue: {
+      disabledItemsFocusable: params.disabledItemsFocusable
+    }
+  };
 };
 useTreeViewNodes.getInitialState = params => updateState({
   items: params.items,
   isItemDisabled: params.isItemDisabled,
   getItemId: params.getItemId,
   getItemLabel: params.getItemLabel
-});
+});
+useTreeViewNodes.getDefaultizedParams = params => {
+  var _params$disabledItems;
+  return _extends({}, params, {
+    disabledItemsFocusable: (_params$disabledItems = params.disabledItemsFocusable) != null ? _params$disabledItems : false
+  });
+};
+useTreeViewNodes.params = {
+  disabledItemsFocusable: true,
+  items: true,
+  isItemDisabled: true,
+  getItemLabel: true,
+  getItemId: true
+};

package/internals/plugins/useTreeViewNodes/useTreeViewNodes.types.d.ts

@@ -62,8 +62,16 @@ export interface UseTreeViewNodesState {
     nodeTree: TreeViewNodeIdAndChildren[];
     nodeMap: TreeViewNodeMap;
 }
-export type UseTreeViewNodesSignature = TreeViewPluginSignature<UseTreeViewNodesParameters<any>, UseTreeViewNodesDefaultizedParameters<any>, UseTreeViewNodesInstance, UseTreeViewNodesEventLookup, UseTreeViewNodesState, never, [
-]>;
+interface UseTreeViewNodesContextValue extends Pick<UseTreeViewNodesDefaultizedParameters<any>, 'disabledItemsFocusable'> {
+}
+export type UseTreeViewNodesSignature = TreeViewPluginSignature<{
+    params: UseTreeViewNodesParameters<any>;
+    defaultizedParams: UseTreeViewNodesDefaultizedParameters<any>;
+    instance: UseTreeViewNodesInstance;
+    events: UseTreeViewNodesEventLookup;
+    state: UseTreeViewNodesState;
+    contextValue: UseTreeViewNodesContextValue;
+}>;
 export type TreeViewNodeMap = {
     [nodeId: string]: TreeViewNode;
 };

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -10,7 +10,6 @@ export const useTreeViewSelection = ({
   const lastSelectedNode = React.useRef(null);
   const lastSelectionWasRange = React.useRef(false);
   const currentRangeSelection = React.useRef([]);
-  const isNodeSelected = nodeId => Array.isArray(models.selectedNodes.value) ? models.selectedNodes.value.indexOf(nodeId) !== -1 : models.selectedNodes.value === nodeId;
   const setSelectedNodes = (event, newSelectedNodes) => {
     if (params.onNodeSelectionToggle) {
       if (params.multiSelect) {
@@ -34,8 +33,9 @@ export const useTreeViewSelection = ({
     if (params.onSelectedNodesChange) {
       params.onSelectedNodesChange(event, newSelectedNodes);
     }
-    models.selectedNodes.setValue(newSelectedNodes);
+    models.selectedNodes.setControlledValue(newSelectedNodes);
   };
+  const isNodeSelected = nodeId => Array.isArray(models.selectedNodes.value) ? models.selectedNodes.value.indexOf(nodeId) !== -1 : models.selectedNodes.value === nodeId;
   const selectNode = (event, nodeId, multiple = false) => {
     if (params.disableSelection) {
       return;
@@ -165,13 +165,17 @@ export const useTreeViewSelection = ({
   return {
     getRootProps: () => ({
       'aria-multiselectable': params.multiSelect
-    })
+    }),
+    contextValue: {
+      selection: {
+        multiSelect: params.multiSelect
+      }
+    }
   };
 };
 useTreeViewSelection.models = {
   selectedNodes: {
-    controlledProp: 'selectedNodes',
-    defaultProp: 'defaultSelectedNodes'
+    getDefaultValue: params => params.defaultSelectedNodes
   }
 };
 const DEFAULT_SELECTED_NODES = [];
@@ -182,4 +186,12 @@ useTreeViewSelection.getDefaultizedParams = 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/internals/plugins/useTreeViewSelection/useTreeViewSelection.types.d.ts

@@ -48,9 +48,19 @@ export interface UseTreeViewSelectionParameters<Multiple extends boolean | undef
     onNodeSelectionToggle?: (event: React.SyntheticEvent, nodeId: string, isSelected: boolean) => void;
 }
 export type UseTreeViewSelectionDefaultizedParameters<Multiple extends boolean> = DefaultizedProps<UseTreeViewSelectionParameters<Multiple>, 'disableSelection' | 'defaultSelectedNodes' | 'multiSelect'>;
-export type UseTreeViewSelectionSignature = TreeViewPluginSignature<UseTreeViewSelectionParameters<any>, UseTreeViewSelectionDefaultizedParameters<any>, UseTreeViewSelectionInstance, {}, {}, 'selectedNodes', [
-    UseTreeViewNodesSignature,
-    UseTreeViewExpansionSignature,
-    UseTreeViewNodesSignature
-]>;
+interface UseTreeViewSelectionContextValue {
+    selection: Pick<UseTreeViewSelectionDefaultizedParameters<boolean>, 'multiSelect'>;
+}
+export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
+    params: UseTreeViewSelectionParameters<any>;
+    defaultizedParams: UseTreeViewSelectionDefaultizedParameters<any>;
+    instance: UseTreeViewSelectionInstance;
+    contextValue: UseTreeViewSelectionContextValue;
+    modelNames: 'selectedNodes';
+    dependantPlugins: [
+        UseTreeViewNodesSignature,
+        UseTreeViewExpansionSignature,
+        UseTreeViewNodesSignature
+    ];
+}>;
 export {};

package/internals/useTreeView/useTreeView.js

@@ -26,11 +26,15 @@ export const useTreeView = inParams => {
     return temp;
   });
   const rootPropsGetters = [];
-  let contextValue = {};
+  const contextValue = {
+    instance: instance
+  };
   const runPlugin = plugin => {
     const pluginResponse = plugin({
       instance,
       params,
+      slots: params.slots,
+      slotProps: params.slotProps,
       state,
       setState,
       rootRef: innerRootRef,
@@ -40,7 +44,7 @@ export const useTreeView = inParams => {
       rootPropsGetters.push(pluginResponse.getRootProps);
     }
     if (pluginResponse.contextValue) {
-      contextValue = pluginResponse.contextValue;
+      Object.assign(contextValue, pluginResponse.contextValue);
     }
   };
   plugins.forEach(runPlugin);
@@ -96,7 +100,7 @@ export const useTreeView = inParams => {
   return {
     getRootProps,
     rootRef: handleRootRef,
-    contextValue,
+    contextValue: contextValue,
     instance: instance
   };
 };