@mui/x-tree-view 6.0.0-alpha.3 → 6.0.0-alpha.4

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

@@ -0,0 +1,226 @@
+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/);
+}
+function findNextFirstChar(firstChars, startIndex, char) {
+  for (var i = startIndex; i < firstChars.length; i += 1) {
+    if (char === firstChars[i]) {
+      return i;
+    }
+  }
+  return -1;
+}
+export var useTreeViewKeyboardNavigation = function useTreeViewKeyboardNavigation(_ref) {
+  var instance = _ref.instance,
+    params = _ref.params,
+    state = _ref.state;
+  var theme = useTheme();
+  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;
+    };
+  });
+  populateInstance(instance, {
+    mapFirstChar: mapFirstChar
+  });
+  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 start;
+    var index;
+    var lowercaseChar = firstChar.toLowerCase();
+    var firstCharIds = [];
+    var firstChars = [];
+    // This really only works since the ids are strings
+    Object.keys(firstCharMap.current).forEach(function (mapNodeId) {
+      var map = instance.getNode(mapNodeId);
+      var visible = map.parentId ? instance.isNodeExpanded(map.parentId) : true;
+      var shouldBeSkipped = params.disabledItemsFocusable ? false : instance.isNodeDisabled(mapNodeId);
+      if (visible && !shouldBeSkipped) {
+        firstCharIds.push(mapNodeId);
+        firstChars.push(firstCharMap.current[mapNodeId]);
+      }
+    });
+
+    // Get start index for search based on position of currentItem
+    start = firstCharIds.indexOf(nodeId) + 1;
+    if (start >= firstCharIds.length) {
+      start = 0;
+    }
+
+    // Check remaining slots in the menu
+    index = findNextFirstChar(firstChars, start, lowercaseChar);
+
+    // If not found in remaining slots, check from beginning
+    if (index === -1) {
+      index = findNextFirstChar(firstChars, 0, lowercaseChar);
+    }
+
+    // If match was found...
+    if (index > -1) {
+      instance.focusNode(event, firstCharIds[index]);
+    }
+  };
+  var selectNextNode = function selectNextNode(event, id) {
+    if (!instance.isNodeDisabled(getNextNode(instance, id))) {
+      instance.selectRange(event, {
+        end: getNextNode(instance, id),
+        current: id
+      }, true);
+    }
+  };
+  var selectPreviousNode = function selectPreviousNode(event, nodeId) {
+    if (!instance.isNodeDisabled(getPreviousNode(instance, nodeId))) {
+      instance.selectRange(event, {
+        end: getPreviousNode(instance, nodeId),
+        current: nodeId
+      }, true);
+    }
+  };
+  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 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;
+            if (params.multiSelect && event.shiftKey) {
+              instance.selectRange(event, {
+                end: state.focusedNodeId
+              });
+            } else if (params.multiSelect) {
+              instance.selectNode(event, state.focusedNodeId, true);
+            } else {
+              instance.selectNode(event, state.focusedNodeId);
+            }
+          }
+          event.stopPropagation();
+          break;
+        case 'Enter':
+          if (!instance.isNodeDisabled(state.focusedNodeId)) {
+            if (instance.isNodeExpandable(state.focusedNodeId)) {
+              instance.toggleNodeExpansion(event, state.focusedNodeId);
+              flag = true;
+            } else if (!params.disableSelection) {
+              flag = true;
+              if (params.multiSelect) {
+                instance.selectNode(event, state.focusedNodeId, true);
+              } else {
+                instance.selectNode(event, state.focusedNodeId);
+              }
+            }
+          }
+          event.stopPropagation();
+          break;
+        case 'ArrowDown':
+          if (params.multiSelect && event.shiftKey && !params.disableSelection) {
+            selectNextNode(event, state.focusedNodeId);
+          }
+          instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
+          flag = true;
+          break;
+        case 'ArrowUp':
+          if (params.multiSelect && event.shiftKey && !params.disableSelection) {
+            selectPreviousNode(event, state.focusedNodeId);
+          }
+          instance.focusNode(event, getPreviousNode(instance, state.focusedNodeId));
+          flag = true;
+          break;
+        case 'ArrowRight':
+          if (isRtl) {
+            flag = handlePreviousArrow(event);
+          } else {
+            flag = handleNextArrow(event);
+          }
+          break;
+        case 'ArrowLeft':
+          if (isRtl) {
+            flag = handleNextArrow(event);
+          } else {
+            flag = handlePreviousArrow(event);
+          }
+          break;
+        case 'Home':
+          if (params.multiSelect && ctrlPressed && event.shiftKey && !params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
+            instance.rangeSelectToFirst(event, state.focusedNodeId);
+          }
+          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);
+          }
+          instance.focusNode(event, getLastNode(instance));
+          flag = true;
+          break;
+        default:
+          if (key === '*') {
+            instance.expandAllSiblings(event, state.focusedNodeId);
+            flag = true;
+          } else if (params.multiSelect && ctrlPressed && key.toLowerCase() === 'a' && !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;
+          }
+      }
+      if (flag) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    };
+  };
+  return {
+    getRootProps: function getRootProps(otherHandlers) {
+      return {
+        onKeyDown: createHandleKeyDown(otherHandlers)
+      };
+    }
+  };
+};

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

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

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

@@ -0,0 +1 @@
+export { useTreeViewNodes } from './useTreeViewNodes';

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

@@ -0,0 +1,71 @@
+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 { publishTreeViewEvent } from '../../utils/publishTreeViewEvent';
+export var useTreeViewNodes = function useTreeViewNodes(_ref) {
+  var instance = _ref.instance,
+    params = _ref.params;
+  var nodeMap = React.useRef({});
+  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]);
+  var isNodeDisabled = React.useCallback(function (nodeId) {
+    if (nodeId == null) {
+      return false;
+    }
+    var node = instance.getNode(nodeId);
+
+    // This can be called before the node has been added to the node map.
+    if (!node) {
+      return false;
+    }
+    if (node.disabled) {
+      return true;
+    }
+    while (node.parentId != null) {
+      node = instance.getNode(node.parentId);
+      if (node.disabled) {
+        return true;
+      }
+    }
+    return false;
+  }, [instance]);
+  var getChildrenIds = useEventCallback(function (nodeId) {
+    return Object.values(nodeMap.current).filter(function (node) {
+      return node.parentId === nodeId;
+    }).sort(function (a, b) {
+      return a.index - b.index;
+    }).map(function (child) {
+      return child.id;
+    });
+  });
+  var getNavigableChildrenIds = function getNavigableChildrenIds(nodeId) {
+    var childrenIds = instance.getChildrenIds(nodeId);
+    if (!params.disabledItemsFocusable) {
+      childrenIds = childrenIds.filter(function (node) {
+        return !instance.isNodeDisabled(node);
+      });
+    }
+    return childrenIds;
+  };
+  populateInstance(instance, {
+    getNode: getNode,
+    updateNode: insertNode,
+    removeNode: removeNode,
+    getChildrenIds: getChildrenIds,
+    getNavigableChildrenIds: getNavigableChildrenIds,
+    isNodeDisabled: isNodeDisabled
+  });
+};

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

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

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

@@ -0,0 +1 @@
+export { useTreeViewSelection } from './useTreeViewSelection';

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

@@ -0,0 +1,188 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { populateInstance, getNextNode, getFirstNode, getLastNode } from '../../useTreeView/useTreeView.utils';
+import { findOrderInTremauxTree } from './useTreeViewSelection.utils';
+export var useTreeViewSelection = function useTreeViewSelection(_ref) {
+  var instance = _ref.instance,
+    params = _ref.params,
+    models = _ref.models;
+  var lastSelectedNode = React.useRef(null);
+  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;
+  };
+  var selectNode = function selectNode(event, nodeId) {
+    var multiple = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (params.disableSelection) {
+      return;
+    }
+    if (multiple) {
+      if (Array.isArray(models.selected.value)) {
+        var newSelected;
+        if (models.selected.value.indexOf(nodeId) !== -1) {
+          newSelected = models.selected.value.filter(function (id) {
+            return id !== nodeId;
+          });
+        } else {
+          newSelected = [nodeId].concat(models.selected.value);
+        }
+        if (params.onNodeSelect) {
+          params.onNodeSelect(event, newSelected);
+        }
+        models.selected.setValue(newSelected);
+      }
+    } else {
+      var _newSelected = params.multiSelect ? [nodeId] : nodeId;
+      if (params.onNodeSelect) {
+        params.onNodeSelect(event, _newSelected);
+      }
+      models.selected.setValue(_newSelected);
+    }
+    lastSelectedNode.current = nodeId;
+    lastSelectionWasRange.current = false;
+    currentRangeSelection.current = [];
+  };
+  var getNodesInRange = function getNodesInRange(nodeAId, nodeBId) {
+    var _findOrderInTremauxTr = findOrderInTremauxTree(instance, nodeAId, nodeBId),
+      _findOrderInTremauxTr2 = _slicedToArray(_findOrderInTremauxTr, 2),
+      first = _findOrderInTremauxTr2[0],
+      last = _findOrderInTremauxTr2[1];
+    var nodes = [first];
+    var current = first;
+    while (current !== last) {
+      current = getNextNode(instance, current);
+      nodes.push(current);
+    }
+    return nodes;
+  };
+  var handleRangeArrowSelect = function handleRangeArrowSelect(event, nodes) {
+    var base = models.selected.value.slice();
+    var start = nodes.start,
+      next = nodes.next,
+      current = nodes.current;
+    if (!next || !current) {
+      return;
+    }
+    if (currentRangeSelection.current.indexOf(current) === -1) {
+      currentRangeSelection.current = [];
+    }
+    if (lastSelectionWasRange.current) {
+      if (currentRangeSelection.current.indexOf(next) !== -1) {
+        base = base.filter(function (id) {
+          return id === start || id !== current;
+        });
+        currentRangeSelection.current = currentRangeSelection.current.filter(function (id) {
+          return id === start || id !== current;
+        });
+      } else {
+        base.push(next);
+        currentRangeSelection.current.push(next);
+      }
+    } else {
+      base.push(next);
+      currentRangeSelection.current.push(current, next);
+    }
+    if (params.onNodeSelect) {
+      params.onNodeSelect(event, base);
+    }
+    models.selected.setValue(base);
+  };
+  var handleRangeSelect = function handleRangeSelect(event, nodes) {
+    var base = models.selected.value.slice();
+    var start = nodes.start,
+      end = nodes.end;
+    // If last selection was a range selection ignore nodes that were selected.
+    if (lastSelectionWasRange.current) {
+      base = base.filter(function (id) {
+        return currentRangeSelection.current.indexOf(id) === -1;
+      });
+    }
+    var range = getNodesInRange(start, end);
+    range = range.filter(function (node) {
+      return !instance.isNodeDisabled(node);
+    });
+    currentRangeSelection.current = range;
+    var newSelected = base.concat(range);
+    newSelected = newSelected.filter(function (id, i) {
+      return newSelected.indexOf(id) === i;
+    });
+    if (params.onNodeSelect) {
+      params.onNodeSelect(event, newSelected);
+    }
+    models.selected.setValue(newSelected);
+  };
+  var selectRange = function selectRange(event, nodes) {
+    var stacked = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (params.disableSelection) {
+      return;
+    }
+    var _nodes$start = nodes.start,
+      start = _nodes$start === void 0 ? lastSelectedNode.current : _nodes$start,
+      end = nodes.end,
+      current = nodes.current;
+    if (stacked) {
+      handleRangeArrowSelect(event, {
+        start: start,
+        next: end,
+        current: current
+      });
+    } else if (start != null && end != null) {
+      handleRangeSelect(event, {
+        start: start,
+        end: end
+      });
+    }
+    lastSelectionWasRange.current = true;
+  };
+  var rangeSelectToFirst = function rangeSelectToFirst(event, nodeId) {
+    if (!lastSelectedNode.current) {
+      lastSelectedNode.current = nodeId;
+    }
+    var start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;
+    instance.selectRange(event, {
+      start: start,
+      end: getFirstNode(instance)
+    });
+  };
+  var rangeSelectToLast = function rangeSelectToLast(event, nodeId) {
+    if (!lastSelectedNode.current) {
+      lastSelectedNode.current = nodeId;
+    }
+    var start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;
+    instance.selectRange(event, {
+      start: start,
+      end: getLastNode(instance)
+    });
+  };
+  populateInstance(instance, {
+    isNodeSelected: isNodeSelected,
+    selectNode: selectNode,
+    selectRange: selectRange,
+    rangeSelectToLast: rangeSelectToLast,
+    rangeSelectToFirst: rangeSelectToFirst
+  });
+  return {
+    getRootProps: function getRootProps() {
+      return {
+        'aria-multiselectable': params.multiSelect
+      };
+    }
+  };
+};
+useTreeViewSelection.models = {
+  selected: {
+    controlledProp: 'selected',
+    defaultProp: 'defaultSelected'
+  }
+};
+var DEFAULT_SELECTED = [];
+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
+  });
+};

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

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

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

@@ -0,0 +1,55 @@
+/**
+ * This is used to determine the start and end of a selection range so
+ * we can get the nodes between the two border nodes.
+ *
+ * It finds the nodes' common ancestor using
+ * a naive implementation of a lowest common ancestor algorithm
+ * (https://en.wikipedia.org/wiki/Lowest_common_ancestor).
+ * Then compares the ancestor's 2 children that are ancestors of nodeA and NodeB
+ * so we can compare their indexes to work out which node comes first in a depth first search.
+ * (https://en.wikipedia.org/wiki/Depth-first_search)
+ *
+ * Another way to put it is which node is shallower in a trémaux tree
+ * https://en.wikipedia.org/wiki/Tr%C3%A9maux_tree
+ */
+export var findOrderInTremauxTree = function findOrderInTremauxTree(instance, nodeAId, nodeBId) {
+  if (nodeAId === nodeBId) {
+    return [nodeAId, nodeBId];
+  }
+  var nodeA = instance.getNode(nodeAId);
+  var nodeB = instance.getNode(nodeBId);
+  if (nodeA.parentId === nodeB.id || nodeB.parentId === nodeA.id) {
+    return nodeB.parentId === nodeA.id ? [nodeA.id, nodeB.id] : [nodeB.id, nodeA.id];
+  }
+  var aFamily = [nodeA.id];
+  var bFamily = [nodeB.id];
+  var aAncestor = nodeA.parentId;
+  var bAncestor = nodeB.parentId;
+  var aAncestorIsCommon = bFamily.indexOf(aAncestor) !== -1;
+  var bAncestorIsCommon = aFamily.indexOf(bAncestor) !== -1;
+  var continueA = true;
+  var continueB = true;
+  while (!bAncestorIsCommon && !aAncestorIsCommon) {
+    if (continueA) {
+      aFamily.push(aAncestor);
+      aAncestorIsCommon = bFamily.indexOf(aAncestor) !== -1;
+      continueA = aAncestor !== null;
+      if (!aAncestorIsCommon && continueA) {
+        aAncestor = instance.getNode(aAncestor).parentId;
+      }
+    }
+    if (continueB && !aAncestorIsCommon) {
+      bFamily.push(bAncestor);
+      bAncestorIsCommon = aFamily.indexOf(bAncestor) !== -1;
+      continueB = bAncestor !== null;
+      if (!bAncestorIsCommon && continueB) {
+        bAncestor = instance.getNode(bAncestor).parentId;
+      }
+    }
+  }
+  var commonAncestor = aAncestorIsCommon ? aAncestor : bAncestor;
+  var ancestorFamily = instance.getChildrenIds(commonAncestor);
+  var aSide = aFamily[aFamily.indexOf(commonAncestor) - 1];
+  var bSide = bFamily[bFamily.indexOf(commonAncestor) - 1];
+  return ancestorFamily.indexOf(aSide) < ancestorFamily.indexOf(bSide) ? [nodeAId, nodeBId] : [nodeBId, nodeAId];
+};

package/legacy/internals/useTreeView/index.js

@@ -0,0 +1 @@
+export { useTreeView } from './useTreeView';

package/legacy/internals/useTreeView/useTreeView.js

@@ -0,0 +1,71 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import useForkRef from '@mui/utils/useForkRef';
+import { DEFAULT_TREE_VIEW_CONTEXT_VALUE } from '../TreeViewProvider/TreeViewContext';
+import { useTreeViewModels } from './useTreeViewModels';
+import { TREE_VIEW_CORE_PLUGINS } from '../corePlugins';
+export var useTreeView = function useTreeView(inParams) {
+  var plugins = [].concat(_toConsumableArray(TREE_VIEW_CORE_PLUGINS), _toConsumableArray(inParams.plugins));
+  var params = plugins.reduce(function (acc, plugin) {
+    if (plugin.getDefaultizedParams) {
+      return plugin.getDefaultizedParams(acc);
+    }
+    return acc;
+  }, inParams);
+  var models = useTreeViewModels(plugins, params);
+  var instanceRef = React.useRef({});
+  var instance = instanceRef.current;
+  var innerRootRef = React.useRef(null);
+  var handleRootRef = useForkRef(innerRootRef, inParams.rootRef);
+  var _React$useState = React.useState(function () {
+      var temp = {};
+      plugins.forEach(function (plugin) {
+        if (plugin.getInitialState) {
+          _extends(temp, plugin.getInitialState(params));
+        }
+      });
+      return temp;
+    }),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    state = _React$useState2[0],
+    setState = _React$useState2[1];
+  var rootPropsGetters = [];
+  var contextValue = DEFAULT_TREE_VIEW_CONTEXT_VALUE;
+  var runPlugin = function runPlugin(plugin) {
+    var pluginResponse = plugin({
+      instance: instance,
+      params: params,
+      state: state,
+      setState: setState,
+      rootRef: innerRootRef,
+      models: models
+    }) || {};
+    if (pluginResponse.getRootProps) {
+      rootPropsGetters.push(pluginResponse.getRootProps);
+    }
+    if (pluginResponse.contextValue) {
+      contextValue = pluginResponse.contextValue;
+    }
+  };
+  plugins.forEach(runPlugin);
+  var getRootProps = function getRootProps() {
+    var otherHandlers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var rootProps = _extends({
+      role: 'tree',
+      tabIndex: 0
+    }, otherHandlers, {
+      ref: handleRootRef
+    });
+    rootPropsGetters.forEach(function (rootPropsGetter) {
+      _extends(rootProps, rootPropsGetter(otherHandlers));
+    });
+    return rootProps;
+  };
+  return {
+    getRootProps: getRootProps,
+    rootRef: handleRootRef,
+    contextValue: contextValue
+  };
+};

package/legacy/internals/useTreeView/useTreeView.types.js

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

package/legacy/internals/useTreeView/useTreeView.utils.js

@@ -0,0 +1,46 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+export var getPreviousNode = function getPreviousNode(instance, nodeId) {
+  var node = instance.getNode(nodeId);
+  var siblings = instance.getNavigableChildrenIds(node.parentId);
+  var nodeIndex = siblings.indexOf(nodeId);
+  if (nodeIndex === 0) {
+    return node.parentId;
+  }
+  var currentNode = siblings[nodeIndex - 1];
+  while (instance.isNodeExpanded(currentNode) && instance.getNavigableChildrenIds(currentNode).length > 0) {
+    currentNode = instance.getNavigableChildrenIds(currentNode).pop();
+  }
+  return currentNode;
+};
+export var getNextNode = function getNextNode(instance, nodeId) {
+  // If expanded get first child
+  if (instance.isNodeExpanded(nodeId) && instance.getNavigableChildrenIds(nodeId).length > 0) {
+    return instance.getNavigableChildrenIds(nodeId)[0];
+  }
+  var node = instance.getNode(nodeId);
+  while (node != null) {
+    // Try to get next sibling
+    var siblings = instance.getNavigableChildrenIds(node.parentId);
+    var nextSibling = siblings[siblings.indexOf(node.id) + 1];
+    if (nextSibling) {
+      return nextSibling;
+    }
+
+    // If the sibling does not exist, go up a level to the parent and try again.
+    node = instance.getNode(node.parentId);
+  }
+  return null;
+};
+export var getLastNode = function getLastNode(instance) {
+  var lastNode = instance.getNavigableChildrenIds(null).pop();
+  while (instance.isNodeExpanded(lastNode)) {
+    lastNode = instance.getNavigableChildrenIds(lastNode).pop();
+  }
+  return lastNode;
+};
+export var getFirstNode = function getFirstNode(instance) {
+  return instance.getNavigableChildrenIds(null)[0];
+};
+export var populateInstance = function populateInstance(instance, methods) {
+  _extends(instance, methods);
+};