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

package/legacy/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js

@@ -1,10 +1,9 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 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) {
@@ -19,45 +18,32 @@ 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 mapFirstChar = useEventCallback(function (nodeId, firstChar) {
-    firstCharMap.current[nodeId] = firstChar;
-    return function () {
-      var newMap = _extends({}, firstCharMap.current);
-      delete newMap[nodeId];
-      firstCharMap.current = newMap;
-    };
+  var hasFirstCharMapBeenUpdatedImperatively = React.useRef(false);
+  var updateFirstCharMap = useEventCallback(function (callback) {
+    hasFirstCharMapBeenUpdatedImperatively.current = true;
+    firstCharMap.current = callback(firstCharMap.current);
   });
+  React.useEffect(function () {
+    if (hasFirstCharMapBeenUpdatedImperatively.current) {
+      return;
+    }
+    var newFirstCharMap = {};
+    var processItem = function processItem(item) {
+      var _item$children;
+      var getItemId = params.getItemId;
+      var nodeId = getItemId ? getItemId(item) : item.id;
+      newFirstCharMap[nodeId] = instance.getNode(nodeId).label.substring(0, 1).toLowerCase();
+      (_item$children = item.children) == null || _item$children.forEach(processItem);
+    };
+    params.items.forEach(processItem);
+    firstCharMap.current = newFirstCharMap;
+  }, [params.items, params.getItemId, instance]);
   populateInstance(instance, {
-    mapFirstChar: mapFirstChar
+    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();
@@ -88,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
@@ -134,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();
       }
     };
   };
@@ -223,4 +280,5 @@ export var useTreeViewKeyboardNavigation = function useTreeViewKeyboardNavigatio
       };
     }
   };
-};
+};
+useTreeViewKeyboardNavigation.params = {};

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

@@ -3,24 +3,54 @@ import * as React from 'react';
 import useEventCallback from '@mui/utils/useEventCallback';
 import { populateInstance } from '../../useTreeView/useTreeView.utils';
 import { publishTreeViewEvent } from '../../utils/publishTreeViewEvent';
-export var useTreeViewNodes = function useTreeViewNodes(_ref) {
-  var instance = _ref.instance,
-    params = _ref.params;
-  var nodeMap = React.useRef({});
+var updateState = function updateState(_ref) {
+  var items = _ref.items,
+    isItemDisabled = _ref.isItemDisabled,
+    getItemLabel = _ref.getItemLabel,
+    getItemId = _ref.getItemId;
+  var nodeMap = {};
+  var processItem = function processItem(item, index, parentId) {
+    var _item$children, _item$children2;
+    var id = getItemId ? getItemId(item) : item.id;
+    if (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.', '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 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,
+      label: label,
+      index: index,
+      parentId: parentId,
+      idAttribute: id,
+      expandable: !!((_item$children = item.children) != null && _item$children.length),
+      disabled: isItemDisabled ? isItemDisabled(item) : false
+    };
+    return {
+      id: id,
+      children: (_item$children2 = item.children) == null ? void 0 : _item$children2.map(function (child, childIndex) {
+        return processItem(child, childIndex, id);
+      })
+    };
+  };
+  var nodeTree = items.map(function (item, itemIndex) {
+    return processItem(item, itemIndex, null);
+  });
+  return {
+    nodeMap: nodeMap,
+    nodeTree: nodeTree
+  };
+};
+export var useTreeViewNodes = function useTreeViewNodes(_ref2) {
+  var instance = _ref2.instance,
+    params = _ref2.params,
+    state = _ref2.state,
+    setState = _ref2.setState;
   var getNode = React.useCallback(function (nodeId) {
-    return nodeMap.current[nodeId];
-  }, []);
-  var insertNode = React.useCallback(function (node) {
-    nodeMap.current[node.id] = node;
-  }, []);
-  var removeNode = React.useCallback(function (nodeId) {
-    var newMap = _extends({}, nodeMap.current);
-    delete newMap[nodeId];
-    nodeMap.current = newMap;
-    publishTreeViewEvent(instance, 'removeNode', {
-      id: nodeId
-    });
-  }, [instance]);
+    return state.nodeMap[nodeId];
+  }, [state.nodeMap]);
   var isNodeDisabled = React.useCallback(function (nodeId) {
     if (nodeId == null) {
       return false;
@@ -43,7 +73,7 @@ export var useTreeViewNodes = function useTreeViewNodes(_ref) {
     return false;
   }, [instance]);
   var getChildrenIds = useEventCallback(function (nodeId) {
-    return Object.values(nodeMap.current).filter(function (node) {
+    return Object.values(state.nodeMap).filter(function (node) {
       return node.parentId === nodeId;
     }).sort(function (a, b) {
       return a.index - b.index;
@@ -60,12 +90,58 @@ export var useTreeViewNodes = function useTreeViewNodes(_ref) {
     }
     return childrenIds;
   };
+  React.useEffect(function () {
+    setState(function (prevState) {
+      var newState = updateState({
+        items: params.items,
+        isItemDisabled: params.isItemDisabled,
+        getItemId: params.getItemId,
+        getItemLabel: params.getItemLabel
+      });
+      Object.values(prevState.nodeMap).forEach(function (node) {
+        if (!newState.nodeMap[node.id]) {
+          publishTreeViewEvent(instance, 'removeNode', {
+            id: node.id
+          });
+        }
+      });
+      return _extends({}, prevState, newState);
+    });
+  }, [instance, setState, params.items, params.isItemDisabled, params.getItemId, params.getItemLabel]);
+  var getNodesToRender = useEventCallback(function () {
+    var getPropsFromNodeId = function getPropsFromNodeId(_ref3) {
+      var id = _ref3.id,
+        children = _ref3.children;
+      var node = state.nodeMap[id];
+      return {
+        label: node.label,
+        nodeId: node.id,
+        id: node.idAttribute,
+        children: children == null ? void 0 : children.map(getPropsFromNodeId)
+      };
+    };
+    return state.nodeTree.map(getPropsFromNodeId);
+  });
   populateInstance(instance, {
     getNode: getNode,
-    updateNode: insertNode,
-    removeNode: removeNode,
+    getNodesToRender: getNodesToRender,
     getChildrenIds: getChildrenIds,
     getNavigableChildrenIds: getNavigableChildrenIds,
     isNodeDisabled: isNodeDisabled
   });
+};
+useTreeViewNodes.getInitialState = function (params) {
+  return updateState({
+    items: params.items,
+    isItemDisabled: params.isItemDisabled,
+    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

@@ -11,7 +11,36 @@ export var useTreeViewSelection = function useTreeViewSelection(_ref) {
   var lastSelectionWasRange = React.useRef(false);
   var currentRangeSelection = React.useRef([]);
   var isNodeSelected = function isNodeSelected(nodeId) {
-    return Array.isArray(models.selected.value) ? models.selected.value.indexOf(nodeId) !== -1 : models.selected.value === nodeId;
+    return Array.isArray(models.selectedNodes.value) ? models.selectedNodes.value.indexOf(nodeId) !== -1 : models.selectedNodes.value === nodeId;
+  };
+  var setSelectedNodes = function setSelectedNodes(event, newSelectedNodes) {
+    if (params.onNodeSelectionToggle) {
+      if (params.multiSelect) {
+        var addedNodes = newSelectedNodes.filter(function (nodeId) {
+          return !instance.isNodeSelected(nodeId);
+        });
+        var removedNodes = models.selectedNodes.value.filter(function (nodeId) {
+          return !newSelectedNodes.includes(nodeId);
+        });
+        addedNodes.forEach(function (nodeId) {
+          params.onNodeSelectionToggle(event, nodeId, true);
+        });
+        removedNodes.forEach(function (nodeId) {
+          params.onNodeSelectionToggle(event, nodeId, false);
+        });
+      } else if (newSelectedNodes !== models.selectedNodes.value) {
+        if (models.selectedNodes.value != null) {
+          params.onNodeSelectionToggle(event, models.selectedNodes.value, false);
+        }
+        if (newSelectedNodes != null) {
+          params.onNodeSelectionToggle(event, newSelectedNodes, true);
+        }
+      }
+    }
+    if (params.onSelectedNodesChange) {
+      params.onSelectedNodesChange(event, newSelectedNodes);
+    }
+    models.selectedNodes.setValue(newSelectedNodes);
   };
   var selectNode = function selectNode(event, nodeId) {
     var multiple = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
@@ -19,26 +48,20 @@ export var useTreeViewSelection = function useTreeViewSelection(_ref) {
       return;
     }
     if (multiple) {
-      if (Array.isArray(models.selected.value)) {
+      if (Array.isArray(models.selectedNodes.value)) {
         var newSelected;
-        if (models.selected.value.indexOf(nodeId) !== -1) {
-          newSelected = models.selected.value.filter(function (id) {
+        if (models.selectedNodes.value.indexOf(nodeId) !== -1) {
+          newSelected = models.selectedNodes.value.filter(function (id) {
             return id !== nodeId;
           });
         } else {
-          newSelected = [nodeId].concat(models.selected.value);
+          newSelected = [nodeId].concat(models.selectedNodes.value);
         }
-        if (params.onNodeSelect) {
-          params.onNodeSelect(event, newSelected);
-        }
-        models.selected.setValue(newSelected);
+        setSelectedNodes(event, newSelected);
       }
     } else {
       var _newSelected = params.multiSelect ? [nodeId] : nodeId;
-      if (params.onNodeSelect) {
-        params.onNodeSelect(event, _newSelected);
-      }
-      models.selected.setValue(_newSelected);
+      setSelectedNodes(event, _newSelected);
     }
     lastSelectedNode.current = nodeId;
     lastSelectionWasRange.current = false;
@@ -58,7 +81,7 @@ export var useTreeViewSelection = function useTreeViewSelection(_ref) {
     return nodes;
   };
   var handleRangeArrowSelect = function handleRangeArrowSelect(event, nodes) {
-    var base = models.selected.value.slice();
+    var base = models.selectedNodes.value.slice();
     var start = nodes.start,
       next = nodes.next,
       current = nodes.current;
@@ -84,13 +107,10 @@ export var useTreeViewSelection = function useTreeViewSelection(_ref) {
       base.push(next);
       currentRangeSelection.current.push(current, next);
     }
-    if (params.onNodeSelect) {
-      params.onNodeSelect(event, base);
-    }
-    models.selected.setValue(base);
+    setSelectedNodes(event, base);
   };
   var handleRangeSelect = function handleRangeSelect(event, nodes) {
-    var base = models.selected.value.slice();
+    var base = models.selectedNodes.value.slice();
     var start = nodes.start,
       end = nodes.end;
     // If last selection was a range selection ignore nodes that were selected.
@@ -108,10 +128,7 @@ export var useTreeViewSelection = function useTreeViewSelection(_ref) {
     newSelected = newSelected.filter(function (id, i) {
       return newSelected.indexOf(id) === i;
     });
-    if (params.onNodeSelect) {
-      params.onNodeSelect(event, newSelected);
-    }
-    models.selected.setValue(newSelected);
+    setSelectedNodes(event, newSelected);
   };
   var selectRange = function selectRange(event, nodes) {
     var stacked = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
@@ -172,17 +189,25 @@ export var useTreeViewSelection = function useTreeViewSelection(_ref) {
   };
 };
 useTreeViewSelection.models = {
-  selected: {
-    controlledProp: 'selected',
-    defaultProp: 'defaultSelected'
+  selectedNodes: {
+    controlledProp: 'selectedNodes',
+    defaultProp: 'defaultSelectedNodes'
   }
 };
-var DEFAULT_SELECTED = [];
+var DEFAULT_SELECTED_NODES = [];
 useTreeViewSelection.getDefaultizedParams = function (params) {
   var _params$disableSelect, _params$multiSelect, _params$defaultSelect;
   return _extends({}, params, {
     disableSelection: (_params$disableSelect = params.disableSelection) != null ? _params$disableSelect : false,
     multiSelect: (_params$multiSelect = params.multiSelect) != null ? _params$multiSelect : false,
-    defaultSelected: (_params$defaultSelect = params.defaultSelected) != null ? _params$defaultSelect : params.multiSelect ? DEFAULT_SELECTED : null
+    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
 };