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

package/node/internals/plugins/useTreeViewFocus/useTreeViewFocus.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewFocus = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _ownerDocument = _interopRequireDefault(require("@mui/utils/ownerDocument"));
+var _useTreeView = require("../../useTreeView/useTreeView.utils");
+var _useInstanceEventHandler = require("../../hooks/useInstanceEventHandler");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const useTreeViewFocus = ({
+  instance,
+  params,
+  state,
+  setState,
+  models,
+  rootRef
+}) => {
+  const setFocusedNodeId = (0, _useEventCallback.default)(nodeId => {
+    const cleanNodeId = typeof nodeId === 'function' ? nodeId(state.focusedNodeId) : nodeId;
+    setState(prevState => (0, _extends2.default)({}, prevState, {
+      focusedNodeId: cleanNodeId
+    }));
+  });
+  const isNodeFocused = React.useCallback(nodeId => state.focusedNodeId === nodeId, [state.focusedNodeId]);
+  const focusNode = (0, _useEventCallback.default)((event, nodeId) => {
+    if (nodeId) {
+      setFocusedNodeId(nodeId);
+      if (params.onNodeFocus) {
+        params.onNodeFocus(event, nodeId);
+      }
+    }
+  });
+  (0, _useTreeView.populateInstance)(instance, {
+    isNodeFocused,
+    focusNode
+  });
+  (0, _useInstanceEventHandler.useInstanceEventHandler)(instance, 'removeNode', ({
+    id
+  }) => {
+    setFocusedNodeId(oldFocusedNodeId => {
+      if (oldFocusedNodeId === id && rootRef.current === (0, _ownerDocument.default)(rootRef.current).activeElement) {
+        return instance.getChildrenIds(null)[0];
+      }
+      return oldFocusedNodeId;
+    });
+  });
+  const createHandleFocus = otherHandlers => event => {
+    otherHandlers.onFocus?.(event);
+
+    // if the event bubbled (which is React specific) we don't want to steal focus
+    if (event.target === event.currentTarget) {
+      const firstSelected = Array.isArray(models.selected.value) ? models.selected.value[0] : models.selected.value;
+      instance.focusNode(event, firstSelected || instance.getNavigableChildrenIds(null)[0]);
+    }
+  };
+  const createHandleBlur = otherHandlers => event => {
+    otherHandlers.onBlur?.(event);
+    setFocusedNodeId(null);
+  };
+  const focusedNode = instance.getNode(state.focusedNodeId);
+  const activeDescendant = focusedNode ? focusedNode.idAttribute : null;
+  return {
+    getRootProps: otherHandlers => ({
+      onFocus: createHandleFocus(otherHandlers),
+      onBlur: createHandleBlur(otherHandlers),
+      'aria-activedescendant': activeDescendant ?? undefined
+    })
+  };
+};
+exports.useTreeViewFocus = useTreeViewFocus;
+useTreeViewFocus.getInitialState = () => ({
+  focusedNodeId: null
+});
+useTreeViewFocus.getDefaultizedParams = params => (0, _extends2.default)({}, params, {
+  disabledItemsFocusable: params.disabledItemsFocusable ?? false
+});

package/node/internals/plugins/useTreeViewFocus/useTreeViewFocus.types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/node/internals/plugins/useTreeViewKeyboardNavigation/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useTreeViewKeyboardNavigation", {
+  enumerable: true,
+  get: function () {
+    return _useTreeViewKeyboardNavigation.useTreeViewKeyboardNavigation;
+  }
+});
+var _useTreeViewKeyboardNavigation = require("./useTreeViewKeyboardNavigation");

package/node/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js

@@ -0,0 +1,232 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewKeyboardNavigation = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _styles = require("@mui/material/styles");
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _useTreeView = require("../../useTreeView/useTreeView.utils");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function isPrintableCharacter(string) {
+  return string && string.length === 1 && string.match(/\S/);
+}
+function findNextFirstChar(firstChars, startIndex, char) {
+  for (let i = startIndex; i < firstChars.length; i += 1) {
+    if (char === firstChars[i]) {
+      return i;
+    }
+  }
+  return -1;
+}
+const useTreeViewKeyboardNavigation = ({
+  instance,
+  params,
+  state
+}) => {
+  const theme = (0, _styles.useTheme)();
+  const isRtl = theme.direction === 'rtl';
+  const firstCharMap = React.useRef({});
+  const mapFirstChar = (0, _useEventCallback.default)((nodeId, firstChar) => {
+    firstCharMap.current[nodeId] = firstChar;
+    return () => {
+      const newMap = (0, _extends2.default)({}, firstCharMap.current);
+      delete newMap[nodeId];
+      firstCharMap.current = newMap;
+    };
+  });
+  (0, _useTreeView.populateInstance)(instance, {
+    mapFirstChar
+  });
+  const handleNextArrow = event => {
+    if (state.focusedNodeId != null && instance.isNodeExpandable(state.focusedNodeId)) {
+      if (instance.isNodeExpanded(state.focusedNodeId)) {
+        instance.focusNode(event, (0, _useTreeView.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) => {
+    let start;
+    let index;
+    const lowercaseChar = firstChar.toLowerCase();
+    const firstCharIds = [];
+    const firstChars = [];
+    // This really only works since the ids are strings
+    Object.keys(firstCharMap.current).forEach(mapNodeId => {
+      const map = instance.getNode(mapNodeId);
+      const visible = map.parentId ? instance.isNodeExpanded(map.parentId) : true;
+      const 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]);
+    }
+  };
+  const selectNextNode = (event, id) => {
+    if (!instance.isNodeDisabled((0, _useTreeView.getNextNode)(instance, id))) {
+      instance.selectRange(event, {
+        end: (0, _useTreeView.getNextNode)(instance, id),
+        current: id
+      }, true);
+    }
+  };
+  const selectPreviousNode = (event, nodeId) => {
+    if (!instance.isNodeDisabled((0, _useTreeView.getPreviousNode)(instance, nodeId))) {
+      instance.selectRange(event, {
+        end: (0, _useTreeView.getPreviousNode)(instance, nodeId),
+        current: nodeId
+      }, true);
+    }
+  };
+  const createHandleKeyDown = otherHandlers => event => {
+    otherHandlers.onKeyDown?.(event);
+    let flag = false;
+    const 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;
+    }
+    const 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, (0, _useTreeView.getNextNode)(instance, state.focusedNodeId));
+        flag = true;
+        break;
+      case 'ArrowUp':
+        if (params.multiSelect && event.shiftKey && !params.disableSelection) {
+          selectPreviousNode(event, state.focusedNodeId);
+        }
+        instance.focusNode(event, (0, _useTreeView.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, (0, _useTreeView.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, (0, _useTreeView.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: (0, _useTreeView.getFirstNode)(instance),
+            end: (0, _useTreeView.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: otherHandlers => ({
+      onKeyDown: createHandleKeyDown(otherHandlers)
+    })
+  };
+};
+exports.useTreeViewKeyboardNavigation = useTreeViewKeyboardNavigation;

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

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useTreeViewNodes", {
+  enumerable: true,
+  get: function () {
+    return _useTreeViewNodes.useTreeViewNodes;
+  }
+});
+var _useTreeViewNodes = require("./useTreeViewNodes");

package/node/internals/plugins/useTreeViewNodes/useTreeViewNodes.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewNodes = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _useTreeView = require("../../useTreeView/useTreeView.utils");
+var _publishTreeViewEvent = require("../../utils/publishTreeViewEvent");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const useTreeViewNodes = ({
+  instance,
+  params
+}) => {
+  const nodeMap = React.useRef({});
+  const getNode = React.useCallback(nodeId => nodeMap.current[nodeId], []);
+  const insertNode = React.useCallback(node => {
+    nodeMap.current[node.id] = node;
+  }, []);
+  const removeNode = React.useCallback(nodeId => {
+    const newMap = (0, _extends2.default)({}, nodeMap.current);
+    delete newMap[nodeId];
+    nodeMap.current = newMap;
+    (0, _publishTreeViewEvent.publishTreeViewEvent)(instance, 'removeNode', {
+      id: nodeId
+    });
+  }, [instance]);
+  const isNodeDisabled = React.useCallback(nodeId => {
+    if (nodeId == null) {
+      return false;
+    }
+    let 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]);
+  const getChildrenIds = (0, _useEventCallback.default)(nodeId => Object.values(nodeMap.current).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) {
+      childrenIds = childrenIds.filter(node => !instance.isNodeDisabled(node));
+    }
+    return childrenIds;
+  };
+  (0, _useTreeView.populateInstance)(instance, {
+    getNode,
+    updateNode: insertNode,
+    removeNode,
+    getChildrenIds,
+    getNavigableChildrenIds,
+    isNodeDisabled
+  });
+};
+exports.useTreeViewNodes = useTreeViewNodes;

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

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useTreeViewSelection", {
+  enumerable: true,
+  get: function () {
+    return _useTreeViewSelection.useTreeViewSelection;
+  }
+});
+var _useTreeViewSelection = require("./useTreeViewSelection");

package/node/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -0,0 +1,179 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewSelection = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useTreeView = require("../../useTreeView/useTreeView.utils");
+var _useTreeViewSelection = require("./useTreeViewSelection.utils");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const useTreeViewSelection = ({
+  instance,
+  params,
+  models
+}) => {
+  const lastSelectedNode = React.useRef(null);
+  const lastSelectionWasRange = React.useRef(false);
+  const currentRangeSelection = React.useRef([]);
+  const isNodeSelected = nodeId => Array.isArray(models.selected.value) ? models.selected.value.indexOf(nodeId) !== -1 : models.selected.value === nodeId;
+  const selectNode = (event, nodeId, multiple = false) => {
+    if (params.disableSelection) {
+      return;
+    }
+    if (multiple) {
+      if (Array.isArray(models.selected.value)) {
+        let newSelected;
+        if (models.selected.value.indexOf(nodeId) !== -1) {
+          newSelected = models.selected.value.filter(id => id !== nodeId);
+        } else {
+          newSelected = [nodeId].concat(models.selected.value);
+        }
+        if (params.onNodeSelect) {
+          params.onNodeSelect(event, newSelected);
+        }
+        models.selected.setValue(newSelected);
+      }
+    } else {
+      const newSelected = params.multiSelect ? [nodeId] : nodeId;
+      if (params.onNodeSelect) {
+        params.onNodeSelect(event, newSelected);
+      }
+      models.selected.setValue(newSelected);
+    }
+    lastSelectedNode.current = nodeId;
+    lastSelectionWasRange.current = false;
+    currentRangeSelection.current = [];
+  };
+  const getNodesInRange = (nodeAId, nodeBId) => {
+    const [first, last] = (0, _useTreeViewSelection.findOrderInTremauxTree)(instance, nodeAId, nodeBId);
+    const nodes = [first];
+    let current = first;
+    while (current !== last) {
+      current = (0, _useTreeView.getNextNode)(instance, current);
+      nodes.push(current);
+    }
+    return nodes;
+  };
+  const handleRangeArrowSelect = (event, nodes) => {
+    let base = models.selected.value.slice();
+    const {
+      start,
+      next,
+      current
+    } = nodes;
+    if (!next || !current) {
+      return;
+    }
+    if (currentRangeSelection.current.indexOf(current) === -1) {
+      currentRangeSelection.current = [];
+    }
+    if (lastSelectionWasRange.current) {
+      if (currentRangeSelection.current.indexOf(next) !== -1) {
+        base = base.filter(id => id === start || id !== current);
+        currentRangeSelection.current = currentRangeSelection.current.filter(id => 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);
+  };
+  const handleRangeSelect = (event, nodes) => {
+    let base = models.selected.value.slice();
+    const {
+      start,
+      end
+    } = nodes;
+    // If last selection was a range selection ignore nodes that were selected.
+    if (lastSelectionWasRange.current) {
+      base = base.filter(id => currentRangeSelection.current.indexOf(id) === -1);
+    }
+    let range = getNodesInRange(start, end);
+    range = range.filter(node => !instance.isNodeDisabled(node));
+    currentRangeSelection.current = range;
+    let newSelected = base.concat(range);
+    newSelected = newSelected.filter((id, i) => newSelected.indexOf(id) === i);
+    if (params.onNodeSelect) {
+      params.onNodeSelect(event, newSelected);
+    }
+    models.selected.setValue(newSelected);
+  };
+  const selectRange = (event, nodes, stacked = false) => {
+    if (params.disableSelection) {
+      return;
+    }
+    const {
+      start = lastSelectedNode.current,
+      end,
+      current
+    } = nodes;
+    if (stacked) {
+      handleRangeArrowSelect(event, {
+        start,
+        next: end,
+        current
+      });
+    } else if (start != null && end != null) {
+      handleRangeSelect(event, {
+        start,
+        end
+      });
+    }
+    lastSelectionWasRange.current = true;
+  };
+  const rangeSelectToFirst = (event, nodeId) => {
+    if (!lastSelectedNode.current) {
+      lastSelectedNode.current = nodeId;
+    }
+    const start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;
+    instance.selectRange(event, {
+      start,
+      end: (0, _useTreeView.getFirstNode)(instance)
+    });
+  };
+  const rangeSelectToLast = (event, nodeId) => {
+    if (!lastSelectedNode.current) {
+      lastSelectedNode.current = nodeId;
+    }
+    const start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;
+    instance.selectRange(event, {
+      start,
+      end: (0, _useTreeView.getLastNode)(instance)
+    });
+  };
+  (0, _useTreeView.populateInstance)(instance, {
+    isNodeSelected,
+    selectNode,
+    selectRange,
+    rangeSelectToLast,
+    rangeSelectToFirst
+  });
+  return {
+    getRootProps: () => ({
+      'aria-multiselectable': params.multiSelect
+    })
+  };
+};
+exports.useTreeViewSelection = useTreeViewSelection;
+useTreeViewSelection.models = {
+  selected: {
+    controlledProp: 'selected',
+    defaultProp: 'defaultSelected'
+  }
+};
+const DEFAULT_SELECTED = [];
+useTreeViewSelection.getDefaultizedParams = params => (0, _extends2.default)({}, params, {
+  disableSelection: params.disableSelection ?? false,
+  multiSelect: params.multiSelect ?? false,
+  defaultSelected: params.defaultSelected ?? (params.multiSelect ? DEFAULT_SELECTED : null)
+});

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

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});