@mui/x-tree-view 7.0.0-beta.5 → 7.0.0-beta.7

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

@@ -7,42 +7,42 @@ export const useTreeViewExpansion = ({
   params,
   models
 }) => {
-  const setExpandedNodes = (event, value) => {
-    params.onExpandedNodesChange?.(event, value);
-    models.expandedNodes.setControlledValue(value);
+  const setExpandedItems = (event, value) => {
+    params.onExpandedItemsChange?.(event, value);
+    models.expandedItems.setControlledValue(value);
   };
   const isNodeExpanded = React.useCallback(nodeId => {
-    return Array.isArray(models.expandedNodes.value) ? models.expandedNodes.value.indexOf(nodeId) !== -1 : false;
-  }, [models.expandedNodes.value]);
+    return Array.isArray(models.expandedItems.value) ? models.expandedItems.value.indexOf(nodeId) !== -1 : false;
+  }, [models.expandedItems.value]);
   const isNodeExpandable = React.useCallback(nodeId => !!instance.getNode(nodeId)?.expandable, [instance]);
-  const toggleNodeExpansion = useEventCallback((event, nodeId) => {
-    if (nodeId == null) {
+  const toggleNodeExpansion = useEventCallback((event, itemId) => {
+    if (itemId == null) {
       return;
     }
-    const isExpandedBefore = models.expandedNodes.value.indexOf(nodeId) !== -1;
+    const isExpandedBefore = models.expandedItems.value.indexOf(itemId) !== -1;
     let newExpanded;
     if (isExpandedBefore) {
-      newExpanded = models.expandedNodes.value.filter(id => id !== nodeId);
+      newExpanded = models.expandedItems.value.filter(id => id !== itemId);
     } else {
-      newExpanded = [nodeId].concat(models.expandedNodes.value);
+      newExpanded = [itemId].concat(models.expandedItems.value);
     }
-    if (params.onNodeExpansionToggle) {
-      params.onNodeExpansionToggle(event, nodeId, !isExpandedBefore);
+    if (params.onItemExpansionToggle) {
+      params.onItemExpansionToggle(event, itemId, !isExpandedBefore);
     }
-    setExpandedNodes(event, newExpanded);
+    setExpandedItems(event, newExpanded);
   });
   const expandAllSiblings = (event, nodeId) => {
     const node = instance.getNode(nodeId);
     const siblings = instance.getChildrenIds(node.parentId);
     const diff = siblings.filter(child => instance.isNodeExpandable(child) && !instance.isNodeExpanded(child));
-    const newExpanded = models.expandedNodes.value.concat(diff);
+    const newExpanded = models.expandedItems.value.concat(diff);
     if (diff.length > 0) {
-      if (params.onNodeExpansionToggle) {
+      if (params.onItemExpansionToggle) {
         diff.forEach(newlyExpandedNodeId => {
-          params.onNodeExpansionToggle(event, newlyExpandedNodeId, true);
+          params.onItemExpansionToggle(event, newlyExpandedNodeId, true);
         });
       }
-      setExpandedNodes(event, newExpanded);
+      setExpandedItems(event, newExpanded);
     }
   };
   populateInstance(instance, {
@@ -53,17 +53,17 @@ export const useTreeViewExpansion = ({
   });
 };
 useTreeViewExpansion.models = {
-  expandedNodes: {
-    getDefaultValue: params => params.defaultExpandedNodes
+  expandedItems: {
+    getDefaultValue: params => params.defaultExpandedItems
   }
 };
 const DEFAULT_EXPANDED_NODES = [];
 useTreeViewExpansion.getDefaultizedParams = params => _extends({}, params, {
-  defaultExpandedNodes: params.defaultExpandedNodes ?? DEFAULT_EXPANDED_NODES
+  defaultExpandedItems: params.defaultExpandedItems ?? DEFAULT_EXPANDED_NODES
 });
 useTreeViewExpansion.params = {
-  expandedNodes: true,
-  defaultExpandedNodes: true,
-  onExpandedNodesChange: true,
-  onNodeExpansionToggle: true
+  expandedItems: true,
+  defaultExpandedItems: true,
+  onExpandedItemsChange: true,
+  onItemExpansionToggle: true
 };

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

@@ -28,31 +28,31 @@ export const useTreeViewFocus = ({
     const node = instance.getNode(nodeId);
     return node && (node.parentId == null || instance.isNodeExpanded(node.parentId));
   };
-  const focusNode = useEventCallback((event, nodeId) => {
+  const focusItem = useEventCallback((event, nodeId) => {
     // if we receive a nodeId, and it is visible, the focus will be set to it
     if (nodeId && isNodeVisible(nodeId)) {
       if (!isTreeViewFocused()) {
         instance.focusRoot();
       }
       setFocusedNodeId(nodeId);
-      if (params.onNodeFocus) {
-        params.onNodeFocus(event, nodeId);
+      if (params.onItemFocus) {
+        params.onItemFocus(event, nodeId);
       }
     }
   });
   const focusDefaultNode = useEventCallback(event => {
     let nodeToFocusId;
-    if (Array.isArray(models.selectedNodes.value)) {
-      nodeToFocusId = models.selectedNodes.value.find(isNodeVisible);
-    } else if (models.selectedNodes.value != null && isNodeVisible(models.selectedNodes.value)) {
-      nodeToFocusId = models.selectedNodes.value;
+    if (Array.isArray(models.selectedItems.value)) {
+      nodeToFocusId = models.selectedItems.value.find(isNodeVisible);
+    } else if (models.selectedItems.value != null && isNodeVisible(models.selectedItems.value)) {
+      nodeToFocusId = models.selectedItems.value;
     }
     if (nodeToFocusId == null) {
       nodeToFocusId = instance.getNavigableChildrenIds(null)[0];
     }
     setFocusedNodeId(nodeToFocusId);
-    if (params.onNodeFocus) {
-      params.onNodeFocus(event, nodeToFocusId);
+    if (params.onItemFocus) {
+      params.onItemFocus(event, nodeToFocusId);
     }
   });
   const focusRoot = useEventCallback(() => {
@@ -62,12 +62,12 @@ export const useTreeViewFocus = ({
   });
   populateInstance(instance, {
     isNodeFocused,
-    focusNode,
+    focusItem,
     focusRoot,
     focusDefaultNode
   });
   populatePublicAPI(publicAPI, {
-    focusNode
+    focusItem
   });
   useInstanceEventHandler(instance, 'removeNode', ({
     id
@@ -104,5 +104,5 @@ useTreeViewFocus.getInitialState = () => ({
   focusedNodeId: null
 });
 useTreeViewFocus.params = {
-  onNodeFocus: true
+  onItemFocus: true
 };

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

@@ -13,22 +13,36 @@ export const useTreeViewJSXNodes = ({
 }) => {
   const insertJSXNode = useEventCallback(node => {
     setState(prevState => {
-      if (prevState.nodeMap[node.id] != null) {
+      if (prevState.nodes.nodeMap[node.id] != null) {
         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.', `Tow items were provided with the same id in the \`items\` prop: "${node.id}"`].join('\n'));
       }
       return _extends({}, prevState, {
-        nodeMap: _extends({}, prevState.nodeMap, {
-          [node.id]: node
+        nodes: _extends({}, prevState.nodes, {
+          nodeMap: _extends({}, prevState.nodes.nodeMap, {
+            [node.id]: node
+          }),
+          // For `SimpleTreeView`, we don't have a proper `item` object, so we create a very basic one.
+          itemMap: _extends({}, prevState.nodes.itemMap, {
+            [node.id]: {
+              id: node.id,
+              label: node.label
+            }
+          })
         })
       });
     });
   });
   const removeJSXNode = useEventCallback(nodeId => {
     setState(prevState => {
-      const newMap = _extends({}, prevState.nodeMap);
-      delete newMap[nodeId];
+      const newNodeMap = _extends({}, prevState.nodes.nodeMap);
+      const newItemMap = _extends({}, prevState.nodes.itemMap);
+      delete newNodeMap[nodeId];
+      delete newItemMap[nodeId];
       return _extends({}, prevState, {
-        nodeMap: newMap
+        nodes: _extends({}, prevState.nodes, {
+          nodeMap: newNodeMap,
+          itemMap: newItemMap
+        })
       });
     });
     publishTreeViewEvent(instance, 'removeNode', {
@@ -56,15 +70,15 @@ export const useTreeViewJSXNodes = ({
 };
 const useTreeViewJSXNodesItemPlugin = ({
   props,
-  ref
+  rootRef,
+  contentRef
 }) => {
   const {
     children,
     disabled = false,
     label,
     nodeId,
-    id,
-    ContentProps: inContentProps
+    id
   } = props;
   const {
     instance
@@ -77,8 +91,9 @@ const useTreeViewJSXNodesItemPlugin = ({
   };
   const expandable = isExpandable(children);
   const [treeItemElement, setTreeItemElement] = React.useState(null);
-  const contentRef = React.useRef(null);
-  const handleRef = useForkRef(setTreeItemElement, ref);
+  const pluginContentRef = React.useRef(null);
+  const handleRootRef = useForkRef(setTreeItemElement, rootRef);
+  const handleContentRef = useForkRef(pluginContentRef, contentRef);
   const descendant = React.useMemo(() => ({
     element: treeItemElement,
     id: nodeId
@@ -104,22 +119,21 @@ const useTreeViewJSXNodesItemPlugin = ({
   }, [instance, parentId, index, nodeId, expandable, disabled, id]);
   React.useEffect(() => {
     if (label) {
-      return instance.mapFirstCharFromJSX(nodeId, (contentRef.current?.textContent ?? '').substring(0, 1).toLowerCase());
+      return instance.mapFirstCharFromJSX(nodeId, (pluginContentRef.current?.textContent ?? '').substring(0, 1).toLowerCase());
     }
     return undefined;
   }, [instance, nodeId, label]);
   return {
-    props: _extends({}, props, {
-      ContentProps: _extends({}, inContentProps, {
-        ref: contentRef
-      })
-    }),
-    ref: handleRef,
-    wrapItem: item => /*#__PURE__*/_jsx(DescendantProvider, {
-      id: nodeId,
-      children: item
-    })
+    contentRef: handleContentRef,
+    rootRef: handleRootRef
   };
 };
 useTreeViewJSXNodes.itemPlugin = useTreeViewJSXNodesItemPlugin;
+useTreeViewJSXNodes.wrapItem = ({
+  children,
+  nodeId
+}) => /*#__PURE__*/_jsx(DescendantProvider, {
+  id: nodeId,
+  children: children
+});
 useTreeViewJSXNodes.params = {};

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

@@ -81,7 +81,9 @@ export const useTreeViewKeyboardNavigation = ({
     return null;
   };
   const canToggleNodeSelection = nodeId => !params.disableSelection && !instance.isNodeDisabled(nodeId);
-  const canToggleNodeExpansion = nodeId => !instance.isNodeDisabled(nodeId) && instance.isNodeExpandable(nodeId);
+  const canToggleNodeExpansion = nodeId => {
+    return !instance.isNodeDisabled(nodeId) && instance.isNodeExpandable(nodeId);
+  };
 
   // ARIA specification: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/#keyboardinteraction
   const createHandleKeyDown = otherHandlers => event => {
@@ -90,7 +92,7 @@ export const useTreeViewKeyboardNavigation = ({
       return;
     }
 
-    // If the tree is empty there will be no focused node
+    // If the tree is empty, there will be no focused node
     if (event.altKey || event.currentTarget !== event.target || state.focusedNodeId == null) {
       return;
     }
@@ -140,7 +142,7 @@ export const useTreeViewKeyboardNavigation = ({
           const nextNode = getNextNode(instance, state.focusedNodeId);
           if (nextNode) {
             event.preventDefault();
-            instance.focusNode(event, nextNode);
+            instance.focusItem(event, nextNode);
 
             // Multi select behavior when pressing Shift + ArrowDown
             // Toggles the selection state of the next node
@@ -160,7 +162,7 @@ export const useTreeViewKeyboardNavigation = ({
           const previousNode = getPreviousNode(instance, state.focusedNodeId);
           if (previousNode) {
             event.preventDefault();
-            instance.focusNode(event, previousNode);
+            instance.focusItem(event, previousNode);
 
             // Multi select behavior when pressing Shift + ArrowUp
             // Toggles the selection state of the previous node
@@ -179,7 +181,7 @@ export const useTreeViewKeyboardNavigation = ({
       case key === 'ArrowRight' && !isRTL || key === 'ArrowLeft' && isRTL:
         {
           if (instance.isNodeExpanded(state.focusedNodeId)) {
-            instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
+            instance.focusItem(event, getNextNode(instance, state.focusedNodeId));
             event.preventDefault();
           } else if (canToggleNodeExpansion(state.focusedNodeId)) {
             instance.toggleNodeExpansion(event, state.focusedNodeId);
@@ -198,7 +200,7 @@ export const useTreeViewKeyboardNavigation = ({
           } else {
             const parent = instance.getNode(state.focusedNodeId).parentId;
             if (parent) {
-              instance.focusNode(event, parent);
+              instance.focusItem(event, parent);
               event.preventDefault();
             }
           }
@@ -208,7 +210,7 @@ export const useTreeViewKeyboardNavigation = ({
       // Focuses the first node in the tree
       case key === 'Home':
         {
-          instance.focusNode(event, getFirstNode(instance));
+          instance.focusItem(event, getFirstNode(instance));
 
           // Multi select behavior when pressing Ctrl + Shift + Home
           // Selects the focused node and all nodes up to the first node.
@@ -222,7 +224,7 @@ export const useTreeViewKeyboardNavigation = ({
       // Focuses the last node in the tree
       case key === 'End':
         {
-          instance.focusNode(event, getLastNode(instance));
+          instance.focusItem(event, getLastNode(instance));
 
           // Multi select behavior when pressing Ctrl + Shirt + End
           // Selects the focused node and all the nodes down to the last node.
@@ -259,7 +261,7 @@ export const useTreeViewKeyboardNavigation = ({
         {
           const matchingNode = getFirstMatchingNode(state.focusedNodeId, key);
           if (matchingNode != null) {
-            instance.focusNode(event, matchingNode);
+            instance.focusItem(event, matchingNode);
             event.preventDefault();
           }
           break;

package/modern/internals/plugins/useTreeViewNodes/useTreeViewNodes.js

@@ -1,15 +1,16 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import useEventCallback from '@mui/utils/useEventCallback';
-import { populateInstance } from '../../useTreeView/useTreeView.utils';
+import { populateInstance, populatePublicAPI } from '../../useTreeView/useTreeView.utils';
 import { publishTreeViewEvent } from '../../utils/publishTreeViewEvent';
-const updateState = ({
+const updateNodesState = ({
   items,
   isItemDisabled,
   getItemLabel,
   getItemId
 }) => {
   const nodeMap = {};
+  const itemMap = {};
   const processItem = (item, index, parentId) => {
     const id = getItemId ? getItemId(item) : item.id;
     if (id == null) {
@@ -27,10 +28,11 @@ const updateState = ({
       label,
       index,
       parentId,
-      idAttribute: id,
+      idAttribute: undefined,
       expandable: !!item.children?.length,
       disabled: isItemDisabled ? isItemDisabled(item) : false
     };
+    itemMap[id] = item;
     return {
       id,
       children: item.children?.map((child, childIndex) => processItem(child, childIndex, id))
@@ -39,16 +41,19 @@ const updateState = ({
   const nodeTree = items.map((item, itemIndex) => processItem(item, itemIndex, null));
   return {
     nodeMap,
-    nodeTree
+    nodeTree,
+    itemMap
   };
 };
 export const useTreeViewNodes = ({
   instance,
+  publicAPI,
   params,
   state,
   setState
 }) => {
-  const getNode = React.useCallback(nodeId => state.nodeMap[nodeId], [state.nodeMap]);
+  const getNode = React.useCallback(nodeId => state.nodes.nodeMap[nodeId], [state.nodes.nodeMap]);
+  const getItem = React.useCallback(nodeId => state.nodes.itemMap[nodeId], [state.nodes.itemMap]);
   const isNodeDisabled = React.useCallback(nodeId => {
     if (nodeId == null) {
       return false;
@@ -70,7 +75,7 @@ export const useTreeViewNodes = ({
     }
     return false;
   }, [instance]);
-  const getChildrenIds = useEventCallback(nodeId => Object.values(state.nodeMap).filter(node => node.parentId === nodeId).sort((a, b) => a.index - b.index).map(child => child.id));
+  const getChildrenIds = useEventCallback(nodeId => Object.values(state.nodes.nodeMap).filter(node => node.parentId === nodeId).sort((a, b) => a.index - b.index).map(child => child.id));
   const getNavigableChildrenIds = nodeId => {
     let childrenIds = instance.getChildrenIds(nodeId);
     if (!params.disabledItemsFocusable) {
@@ -80,28 +85,30 @@ export const useTreeViewNodes = ({
   };
   React.useEffect(() => {
     setState(prevState => {
-      const newState = updateState({
+      const newState = updateNodesState({
         items: params.items,
         isItemDisabled: params.isItemDisabled,
         getItemId: params.getItemId,
         getItemLabel: params.getItemLabel
       });
-      Object.values(prevState.nodeMap).forEach(node => {
+      Object.values(prevState.nodes.nodeMap).forEach(node => {
         if (!newState.nodeMap[node.id]) {
           publishTreeViewEvent(instance, 'removeNode', {
             id: node.id
           });
         }
       });
-      return _extends({}, prevState, newState);
+      return _extends({}, prevState, {
+        nodes: newState
+      });
     });
   }, [instance, setState, params.items, params.isItemDisabled, params.getItemId, params.getItemLabel]);
-  const getNodesToRender = useEventCallback(() => {
+  const getNodesToRender = () => {
     const getPropsFromNodeId = ({
       id,
       children
     }) => {
-      const node = state.nodeMap[id];
+      const node = state.nodes.nodeMap[id];
       return {
         label: node.label,
         nodeId: node.id,
@@ -109,26 +116,32 @@ export const useTreeViewNodes = ({
         children: children?.map(getPropsFromNodeId)
       };
     };
-    return state.nodeTree.map(getPropsFromNodeId);
-  });
+    return state.nodes.nodeTree.map(getPropsFromNodeId);
+  };
   populateInstance(instance, {
     getNode,
+    getItem,
     getNodesToRender,
     getChildrenIds,
     getNavigableChildrenIds,
     isNodeDisabled
   });
+  populatePublicAPI(publicAPI, {
+    getItem
+  });
   return {
     contextValue: {
       disabledItemsFocusable: params.disabledItemsFocusable
     }
   };
 };
-useTreeViewNodes.getInitialState = params => updateState({
-  items: params.items,
-  isItemDisabled: params.isItemDisabled,
-  getItemId: params.getItemId,
-  getItemLabel: params.getItemLabel
+useTreeViewNodes.getInitialState = params => ({
+  nodes: updateNodesState({
+    items: params.items,
+    isItemDisabled: params.isItemDisabled,
+    getItemId: params.getItemId,
+    getItemLabel: params.getItemLabel
+  })
 });
 useTreeViewNodes.getDefaultizedParams = params => _extends({}, params, {
   disabledItemsFocusable: params.disabledItemsFocusable ?? false

package/modern/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -10,49 +10,49 @@ export const useTreeViewSelection = ({
   const lastSelectedNode = React.useRef(null);
   const lastSelectionWasRange = React.useRef(false);
   const currentRangeSelection = React.useRef([]);
-  const setSelectedNodes = (event, newSelectedNodes) => {
-    if (params.onNodeSelectionToggle) {
+  const setSelectedItems = (event, newSelectedItems) => {
+    if (params.onItemSelectionToggle) {
       if (params.multiSelect) {
-        const addedNodes = newSelectedNodes.filter(nodeId => !instance.isNodeSelected(nodeId));
-        const removedNodes = models.selectedNodes.value.filter(nodeId => !newSelectedNodes.includes(nodeId));
-        addedNodes.forEach(nodeId => {
-          params.onNodeSelectionToggle(event, nodeId, true);
+        const addedItems = newSelectedItems.filter(itemId => !instance.isNodeSelected(itemId));
+        const removedItems = models.selectedItems.value.filter(itemId => !newSelectedItems.includes(itemId));
+        addedItems.forEach(itemId => {
+          params.onItemSelectionToggle(event, itemId, true);
         });
-        removedNodes.forEach(nodeId => {
-          params.onNodeSelectionToggle(event, nodeId, false);
+        removedItems.forEach(itemId => {
+          params.onItemSelectionToggle(event, itemId, false);
         });
-      } else if (newSelectedNodes !== models.selectedNodes.value) {
-        if (models.selectedNodes.value != null) {
-          params.onNodeSelectionToggle(event, models.selectedNodes.value, false);
+      } else if (newSelectedItems !== models.selectedItems.value) {
+        if (models.selectedItems.value != null) {
+          params.onItemSelectionToggle(event, models.selectedItems.value, false);
         }
-        if (newSelectedNodes != null) {
-          params.onNodeSelectionToggle(event, newSelectedNodes, true);
+        if (newSelectedItems != null) {
+          params.onItemSelectionToggle(event, newSelectedItems, true);
         }
       }
     }
-    if (params.onSelectedNodesChange) {
-      params.onSelectedNodesChange(event, newSelectedNodes);
+    if (params.onSelectedItemsChange) {
+      params.onSelectedItemsChange(event, newSelectedItems);
     }
-    models.selectedNodes.setControlledValue(newSelectedNodes);
+    models.selectedItems.setControlledValue(newSelectedItems);
   };
-  const isNodeSelected = nodeId => Array.isArray(models.selectedNodes.value) ? models.selectedNodes.value.indexOf(nodeId) !== -1 : models.selectedNodes.value === nodeId;
+  const isNodeSelected = nodeId => Array.isArray(models.selectedItems.value) ? models.selectedItems.value.indexOf(nodeId) !== -1 : models.selectedItems.value === nodeId;
   const selectNode = (event, nodeId, multiple = false) => {
     if (params.disableSelection) {
       return;
     }
     if (multiple) {
-      if (Array.isArray(models.selectedNodes.value)) {
+      if (Array.isArray(models.selectedItems.value)) {
         let newSelected;
-        if (models.selectedNodes.value.indexOf(nodeId) !== -1) {
-          newSelected = models.selectedNodes.value.filter(id => id !== nodeId);
+        if (models.selectedItems.value.indexOf(nodeId) !== -1) {
+          newSelected = models.selectedItems.value.filter(id => id !== nodeId);
         } else {
-          newSelected = [nodeId].concat(models.selectedNodes.value);
+          newSelected = [nodeId].concat(models.selectedItems.value);
         }
-        setSelectedNodes(event, newSelected);
+        setSelectedItems(event, newSelected);
       }
     } else {
       const newSelected = params.multiSelect ? [nodeId] : nodeId;
-      setSelectedNodes(event, newSelected);
+      setSelectedItems(event, newSelected);
     }
     lastSelectedNode.current = nodeId;
     lastSelectionWasRange.current = false;
@@ -69,7 +69,7 @@ export const useTreeViewSelection = ({
     return nodes;
   };
   const handleRangeArrowSelect = (event, nodes) => {
-    let base = models.selectedNodes.value.slice();
+    let base = models.selectedItems.value.slice();
     const {
       start,
       next,
@@ -93,10 +93,10 @@ export const useTreeViewSelection = ({
       base.push(next);
       currentRangeSelection.current.push(current, next);
     }
-    setSelectedNodes(event, base);
+    setSelectedItems(event, base);
   };
   const handleRangeSelect = (event, nodes) => {
-    let base = models.selectedNodes.value.slice();
+    let base = models.selectedItems.value.slice();
     const {
       start,
       end
@@ -110,7 +110,7 @@ export const useTreeViewSelection = ({
     currentRangeSelection.current = range;
     let newSelected = base.concat(range);
     newSelected = newSelected.filter((id, i) => newSelected.indexOf(id) === i);
-    setSelectedNodes(event, newSelected);
+    setSelectedItems(event, newSelected);
   };
   const selectRange = (event, nodes, stacked = false) => {
     if (params.disableSelection) {
@@ -174,21 +174,21 @@ export const useTreeViewSelection = ({
   };
 };
 useTreeViewSelection.models = {
-  selectedNodes: {
-    getDefaultValue: params => params.defaultSelectedNodes
+  selectedItems: {
+    getDefaultValue: params => params.defaultSelectedItems
   }
 };
 const DEFAULT_SELECTED_NODES = [];
 useTreeViewSelection.getDefaultizedParams = params => _extends({}, params, {
   disableSelection: params.disableSelection ?? false,
   multiSelect: params.multiSelect ?? false,
-  defaultSelectedNodes: params.defaultSelectedNodes ?? (params.multiSelect ? DEFAULT_SELECTED_NODES : null)
+  defaultSelectedItems: params.defaultSelectedItems ?? (params.multiSelect ? DEFAULT_SELECTED_NODES : null)
 });
 useTreeViewSelection.params = {
   disableSelection: true,
   multiSelect: true,
-  defaultSelectedNodes: true,
-  selectedNodes: true,
-  onSelectedNodesChange: true,
-  onNodeSelectionToggle: true
+  defaultSelectedItems: true,
+  selectedItems: true,
+  onSelectedItemsChange: true,
+  onItemSelectionToggle: true
 };