@mui/x-tree-view 7.0.0 → 7.1.0

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

@@ -1,19 +1,19 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { populateInstance, getNextNode, getFirstNode, getLastNode } from '../../useTreeView/useTreeView.utils';
+import { populateInstance, getNextItem, getFirstItem, getLastItem } from '../../useTreeView/useTreeView.utils';
 import { findOrderInTremauxTree } from './useTreeViewSelection.utils';
 export const useTreeViewSelection = ({
   instance,
   params,
   models
 }) => {
-  const lastSelectedNode = React.useRef(null);
+  const lastSelectedItem = React.useRef(null);
   const lastSelectionWasRange = React.useRef(false);
   const currentRangeSelection = React.useRef([]);
   const setSelectedItems = (event, newSelectedItems) => {
     if (params.onItemSelectionToggle) {
       if (params.multiSelect) {
-        const addedItems = newSelectedItems.filter(itemId => !instance.isNodeSelected(itemId));
+        const addedItems = newSelectedItems.filter(itemId => !instance.isItemSelected(itemId));
         const removedItems = models.selectedItems.value.filter(itemId => !newSelectedItems.includes(itemId));
         addedItems.forEach(itemId => {
           params.onItemSelectionToggle(event, itemId, true);
@@ -35,8 +35,8 @@ export const useTreeViewSelection = ({
     }
     models.selectedItems.setControlledValue(newSelectedItems);
   };
-  const isNodeSelected = itemId => Array.isArray(models.selectedItems.value) ? models.selectedItems.value.indexOf(itemId) !== -1 : models.selectedItems.value === itemId;
-  const selectNode = (event, itemId, multiple = false) => {
+  const isItemSelected = itemId => Array.isArray(models.selectedItems.value) ? models.selectedItems.value.indexOf(itemId) !== -1 : models.selectedItems.value === itemId;
+  const selectItem = (event, itemId, multiple = false) => {
     if (params.disableSelection) {
       return;
     }
@@ -54,27 +54,27 @@ export const useTreeViewSelection = ({
       const newSelected = params.multiSelect ? [itemId] : itemId;
       setSelectedItems(event, newSelected);
     }
-    lastSelectedNode.current = itemId;
+    lastSelectedItem.current = itemId;
     lastSelectionWasRange.current = false;
     currentRangeSelection.current = [];
   };
-  const getNodesInRange = (nodeAId, nodeBId) => {
-    const [first, last] = findOrderInTremauxTree(instance, nodeAId, nodeBId);
-    const nodes = [first];
+  const getItemsInRange = (itemAId, itemBId) => {
+    const [first, last] = findOrderInTremauxTree(instance, itemAId, itemBId);
+    const items = [first];
     let current = first;
     while (current !== last) {
-      current = getNextNode(instance, current);
-      nodes.push(current);
+      current = getNextItem(instance, current);
+      items.push(current);
     }
-    return nodes;
+    return items;
   };
-  const handleRangeArrowSelect = (event, nodes) => {
+  const handleRangeArrowSelect = (event, items) => {
     let base = models.selectedItems.value.slice();
     const {
       start,
       next,
       current
-    } = nodes;
+    } = items;
     if (!next || !current) {
       return;
     }
@@ -95,32 +95,32 @@ export const useTreeViewSelection = ({
     }
     setSelectedItems(event, base);
   };
-  const handleRangeSelect = (event, nodes) => {
+  const handleRangeSelect = (event, items) => {
     let base = models.selectedItems.value.slice();
     const {
       start,
       end
-    } = nodes;
-    // If last selection was a range selection ignore nodes that were selected.
+    } = items;
+    // If last selection was a range selection ignore items 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));
+    let range = getItemsInRange(start, end);
+    range = range.filter(item => !instance.isItemDisabled(item));
     currentRangeSelection.current = range;
     let newSelected = base.concat(range);
     newSelected = newSelected.filter((id, i) => newSelected.indexOf(id) === i);
     setSelectedItems(event, newSelected);
   };
-  const selectRange = (event, nodes, stacked = false) => {
+  const selectRange = (event, items, stacked = false) => {
     if (params.disableSelection) {
       return;
     }
     const {
-      start = lastSelectedNode.current,
+      start = lastSelectedItem.current,
       end,
       current
-    } = nodes;
+    } = items;
     if (stacked) {
       handleRangeArrowSelect(event, {
         start,
@@ -136,28 +136,28 @@ export const useTreeViewSelection = ({
     lastSelectionWasRange.current = true;
   };
   const rangeSelectToFirst = (event, itemId) => {
-    if (!lastSelectedNode.current) {
-      lastSelectedNode.current = itemId;
+    if (!lastSelectedItem.current) {
+      lastSelectedItem.current = itemId;
     }
-    const start = lastSelectionWasRange.current ? lastSelectedNode.current : itemId;
+    const start = lastSelectionWasRange.current ? lastSelectedItem.current : itemId;
     instance.selectRange(event, {
       start,
-      end: getFirstNode(instance)
+      end: getFirstItem(instance)
     });
   };
   const rangeSelectToLast = (event, itemId) => {
-    if (!lastSelectedNode.current) {
-      lastSelectedNode.current = itemId;
+    if (!lastSelectedItem.current) {
+      lastSelectedItem.current = itemId;
     }
-    const start = lastSelectionWasRange.current ? lastSelectedNode.current : itemId;
+    const start = lastSelectionWasRange.current ? lastSelectedItem.current : itemId;
     instance.selectRange(event, {
       start,
-      end: getLastNode(instance)
+      end: getLastItem(instance)
     });
   };
   populateInstance(instance, {
-    isNodeSelected,
-    selectNode,
+    isItemSelected,
+    selectItem,
     selectRange,
     rangeSelectToLast,
     rangeSelectToFirst
@@ -178,11 +178,11 @@ useTreeViewSelection.models = {
     getDefaultValue: params => params.defaultSelectedItems
   }
 };
-const DEFAULT_SELECTED_NODES = [];
+const DEFAULT_SELECTED_ITEMS = [];
 useTreeViewSelection.getDefaultizedParams = params => _extends({}, params, {
   disableSelection: params.disableSelection ?? false,
   multiSelect: params.multiSelect ?? false,
-  defaultSelectedItems: params.defaultSelectedItems ?? (params.multiSelect ? DEFAULT_SELECTED_NODES : null)
+  defaultSelectedItems: params.defaultSelectedItems ?? (params.multiSelect ? DEFAULT_SELECTED_ITEMS : null)
 });
 useTreeViewSelection.params = {
   disableSelection: true,

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

@@ -1,15 +1,15 @@
 /**
  * This is used to determine the start and end of a selection range so
- * we can get the nodes between the two border nodes.
+ * we can get the items between the two border items.
  *
- * It finds the nodes' common ancestor using
+ * It finds the items' 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.
+ * Then compares the ancestor's 2 children that are ancestors of itemA and ItemB
+ * so we can compare their indexes to work out which item 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
+ * Another way to put it is which item is shallower in a trémaux tree
  * https://en.wikipedia.org/wiki/Tr%C3%A9maux_tree
  */
 export const findOrderInTremauxTree = (instance, nodeAId, nodeBId) => {

package/modern/internals/useTreeView/useTreeView.utils.js

@@ -1,43 +1,43 @@
-export const getPreviousNode = (instance, itemId) => {
-  const item = instance.getNode(itemId);
-  const siblings = instance.getNavigableChildrenIds(item.parentId);
+export const getPreviousItem = (instance, itemId) => {
+  const node = instance.getNode(itemId);
+  const siblings = instance.getNavigableChildrenIds(node.parentId);
   const itemIndex = siblings.indexOf(itemId);
   if (itemIndex === 0) {
-    return item.parentId;
+    return node.parentId;
   }
   let currentItem = siblings[itemIndex - 1];
-  while (instance.isNodeExpanded(currentItem) && instance.getNavigableChildrenIds(currentItem).length > 0) {
+  while (instance.isItemExpanded(currentItem) && instance.getNavigableChildrenIds(currentItem).length > 0) {
     currentItem = instance.getNavigableChildrenIds(currentItem).pop();
   }
   return currentItem;
 };
-export const getNextNode = (instance, itemId) => {
+export const getNextItem = (instance, itemId) => {
   // If expanded get first child
-  if (instance.isNodeExpanded(itemId) && instance.getNavigableChildrenIds(itemId).length > 0) {
+  if (instance.isItemExpanded(itemId) && instance.getNavigableChildrenIds(itemId).length > 0) {
     return instance.getNavigableChildrenIds(itemId)[0];
   }
-  let item = instance.getNode(itemId);
-  while (item != null) {
+  let node = instance.getNode(itemId);
+  while (node != null) {
     // Try to get next sibling
-    const siblings = instance.getNavigableChildrenIds(item.parentId);
-    const nextSibling = siblings[siblings.indexOf(item.id) + 1];
+    const siblings = instance.getNavigableChildrenIds(node.parentId);
+    const 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.
-    item = instance.getNode(item.parentId);
+    node = instance.getNode(node.parentId);
   }
   return null;
 };
-export const getLastNode = instance => {
+export const getLastItem = instance => {
   let lastItem = instance.getNavigableChildrenIds(null).pop();
-  while (instance.isNodeExpanded(lastItem)) {
+  while (instance.isItemExpanded(lastItem)) {
     lastItem = instance.getNavigableChildrenIds(lastItem).pop();
   }
   return lastItem;
 };
-export const getFirstNode = instance => instance.getNavigableChildrenIds(null)[0];
+export const getFirstItem = instance => instance.getNavigableChildrenIds(null)[0];
 export const populateInstance = (instance, methods) => {
   Object.assign(instance, methods);
 };

package/node/RichTreeView/RichTreeView.js

@@ -113,8 +113,8 @@ const RichTreeView = exports.RichTreeView = /*#__PURE__*/React.forwardRef(functi
     getSlotProps: getRootProps,
     ownerState: props
   });
-  const nodesToRender = instance.getNodesToRender();
-  const renderNode = ({
+  const itemsToRender = instance.getItemsToRender();
+  const renderItem = ({
     label,
     itemId,
     id,
@@ -126,13 +126,13 @@ const RichTreeView = exports.RichTreeView = /*#__PURE__*/React.forwardRef(functi
       label: label,
       id: id,
       itemId: itemId,
-      children: children?.map(renderNode)
+      children: children?.map(renderItem)
     }, itemId);
   };
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(_TreeViewProvider.TreeViewProvider, {
     value: contextValue,
     children: /*#__PURE__*/(0, _jsxRuntime.jsx)(Root, (0, _extends2.default)({}, rootProps, {
-      children: nodesToRender.map(renderNode)
+      children: itemsToRender.map(renderItem)
     }))
   });
 });

package/node/SimpleTreeView/SimpleTreeView.plugins.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.SIMPLE_TREE_VIEW_PLUGINS = void 0;
 var _defaultPlugins = require("../internals/plugins/defaultPlugins");
-var _useTreeViewJSXNodes = require("../internals/plugins/useTreeViewJSXNodes");
-const SIMPLE_TREE_VIEW_PLUGINS = exports.SIMPLE_TREE_VIEW_PLUGINS = [..._defaultPlugins.DEFAULT_TREE_VIEW_PLUGINS, _useTreeViewJSXNodes.useTreeViewJSXNodes];
+var _useTreeViewJSXItems = require("../internals/plugins/useTreeViewJSXItems");
+const SIMPLE_TREE_VIEW_PLUGINS = exports.SIMPLE_TREE_VIEW_PLUGINS = [..._defaultPlugins.DEFAULT_TREE_VIEW_PLUGINS, _useTreeViewJSXItems.useTreeViewJSXItems];
 
 // We can't infer this type from the plugin, otherwise we would lose the generics.

package/node/TreeItem/TreeItem.js

@@ -194,10 +194,10 @@ const TreeItem = exports.TreeItem = /*#__PURE__*/React.forwardRef(function TreeI
     return Boolean(reactChildren);
   };
   const expandable = isExpandable(children);
-  const expanded = instance.isNodeExpanded(itemId);
-  const focused = instance.isNodeFocused(itemId);
-  const selected = instance.isNodeSelected(itemId);
-  const disabled = instance.isNodeDisabled(itemId);
+  const expanded = instance.isItemExpanded(itemId);
+  const focused = instance.isItemFocused(itemId);
+  const selected = instance.isItemSelected(itemId);
+  const disabled = instance.isItemDisabled(itemId);
   const ownerState = (0, _extends2.default)({}, props, {
     expanded,
     focused,

package/node/TreeItem/useTreeItemState.js

@@ -12,11 +12,11 @@ function useTreeItemState(itemId) {
       multiSelect
     }
   } = (0, _useTreeViewContext.useTreeViewContext)();
-  const expandable = instance.isNodeExpandable(itemId);
-  const expanded = instance.isNodeExpanded(itemId);
-  const focused = instance.isNodeFocused(itemId);
-  const selected = instance.isNodeSelected(itemId);
-  const disabled = instance.isNodeDisabled(itemId);
+  const expandable = instance.isItemExpandable(itemId);
+  const expanded = instance.isItemExpanded(itemId);
+  const focused = instance.isItemFocused(itemId);
+  const selected = instance.isItemSelected(itemId);
+  const disabled = instance.isItemDisabled(itemId);
   const handleExpansion = event => {
     if (!disabled) {
       if (!focused) {
@@ -25,8 +25,8 @@ function useTreeItemState(itemId) {
       const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
 
       // If already expanded and trying to toggle selection don't close
-      if (expandable && !(multiple && instance.isNodeExpanded(itemId))) {
-        instance.toggleNodeExpansion(event, itemId);
+      if (expandable && !(multiple && instance.isItemExpanded(itemId))) {
+        instance.toggleItemExpansion(event, itemId);
       }
     }
   };
@@ -42,10 +42,10 @@ function useTreeItemState(itemId) {
             end: itemId
           });
         } else {
-          instance.selectNode(event, itemId, true);
+          instance.selectItem(event, itemId, true);
         }
       } else {
-        instance.selectNode(event, itemId);
+        instance.selectItem(event, itemId);
       }
     }
   };

package/node/hooks/useTreeItem2Utils/useTreeItem2Utils.js

@@ -17,10 +17,10 @@ const useTreeItem2Utils = ({
   } = (0, _useTreeViewContext.useTreeViewContext)();
   const status = {
     expandable: Boolean(Array.isArray(children) ? children.length : children),
-    expanded: instance.isNodeExpanded(itemId),
-    focused: instance.isNodeFocused(itemId),
-    selected: instance.isNodeSelected(itemId),
-    disabled: instance.isNodeDisabled(itemId)
+    expanded: instance.isItemExpanded(itemId),
+    focused: instance.isItemFocused(itemId),
+    selected: instance.isItemSelected(itemId),
+    disabled: instance.isItemDisabled(itemId)
   };
   const handleExpansion = event => {
     if (status.disabled) {
@@ -32,8 +32,8 @@ const useTreeItem2Utils = ({
     const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
 
     // If already expanded and trying to toggle selection don't close
-    if (status.expandable && !(multiple && instance.isNodeExpanded(itemId))) {
-      instance.toggleNodeExpansion(event, itemId);
+    if (status.expandable && !(multiple && instance.isItemExpanded(itemId))) {
+      instance.toggleItemExpansion(event, itemId);
     }
   };
   const handleSelection = event => {
@@ -50,10 +50,10 @@ const useTreeItem2Utils = ({
           end: itemId
         });
       } else {
-        instance.selectNode(event, itemId, true);
+        instance.selectItem(event, itemId, true);
       }
     } else {
-      instance.selectNode(event, itemId);
+      instance.selectItem(event, itemId);
     }
   };
   const interactions = {

package/node/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-tree-view v7.0.0
+ * @mui/x-tree-view v7.1.0
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/node/internals/TreeViewProvider/DescendantProvider.js

@@ -55,7 +55,7 @@ const noop = () => {};
  * We use this for focus management, keyboard navigation, and typeahead
  * functionality for some components.
  *
- * The hook accepts the element node
+ * The hook accepts the element item
  *
  * Our main goals with this are:
  *   1) maximum composability,

package/node/internals/plugins/defaultPlugins.js

@@ -5,12 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.DEFAULT_TREE_VIEW_PLUGINS = void 0;
 var _useTreeViewId = require("./useTreeViewId");
-var _useTreeViewNodes = require("./useTreeViewNodes");
+var _useTreeViewItems = require("./useTreeViewItems");
 var _useTreeViewExpansion = require("./useTreeViewExpansion");
 var _useTreeViewSelection = require("./useTreeViewSelection");
 var _useTreeViewFocus = require("./useTreeViewFocus");
 var _useTreeViewKeyboardNavigation = require("./useTreeViewKeyboardNavigation");
 var _useTreeViewIcons = require("./useTreeViewIcons");
-const DEFAULT_TREE_VIEW_PLUGINS = exports.DEFAULT_TREE_VIEW_PLUGINS = [_useTreeViewId.useTreeViewId, _useTreeViewNodes.useTreeViewNodes, _useTreeViewExpansion.useTreeViewExpansion, _useTreeViewSelection.useTreeViewSelection, _useTreeViewFocus.useTreeViewFocus, _useTreeViewKeyboardNavigation.useTreeViewKeyboardNavigation, _useTreeViewIcons.useTreeViewIcons];
+const DEFAULT_TREE_VIEW_PLUGINS = exports.DEFAULT_TREE_VIEW_PLUGINS = [_useTreeViewId.useTreeViewId, _useTreeViewItems.useTreeViewItems, _useTreeViewExpansion.useTreeViewExpansion, _useTreeViewSelection.useTreeViewSelection, _useTreeViewFocus.useTreeViewFocus, _useTreeViewKeyboardNavigation.useTreeViewKeyboardNavigation, _useTreeViewIcons.useTreeViewIcons];
 
 // We can't infer this type from the plugin, otherwise we would lose the generics.

package/node/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -20,11 +20,11 @@ const useTreeViewExpansion = ({
     params.onExpandedItemsChange?.(event, value);
     models.expandedItems.setControlledValue(value);
   };
-  const isNodeExpanded = React.useCallback(itemId => {
+  const isItemExpanded = React.useCallback(itemId => {
     return Array.isArray(models.expandedItems.value) ? models.expandedItems.value.indexOf(itemId) !== -1 : false;
   }, [models.expandedItems.value]);
-  const isNodeExpandable = React.useCallback(itemId => !!instance.getNode(itemId)?.expandable, [instance]);
-  const toggleNodeExpansion = (0, _useEventCallback.default)((event, itemId) => {
+  const isItemExpandable = React.useCallback(itemId => !!instance.getNode(itemId)?.expandable, [instance]);
+  const toggleItemExpansion = (0, _useEventCallback.default)((event, itemId) => {
     if (itemId == null) {
       return;
     }
@@ -43,7 +43,7 @@ const useTreeViewExpansion = ({
   const expandAllSiblings = (event, itemId) => {
     const node = instance.getNode(itemId);
     const siblings = instance.getChildrenIds(node.parentId);
-    const diff = siblings.filter(child => instance.isNodeExpandable(child) && !instance.isNodeExpanded(child));
+    const diff = siblings.filter(child => instance.isItemExpandable(child) && !instance.isItemExpanded(child));
     const newExpanded = models.expandedItems.value.concat(diff);
     if (diff.length > 0) {
       if (params.onItemExpansionToggle) {
@@ -55,9 +55,9 @@ const useTreeViewExpansion = ({
     }
   };
   (0, _useTreeView.populateInstance)(instance, {
-    isNodeExpanded,
-    isNodeExpandable,
-    toggleNodeExpansion,
+    isItemExpanded,
+    isItemExpandable,
+    toggleItemExpansion,
     expandAllSiblings
   });
 };
@@ -67,9 +67,9 @@ useTreeViewExpansion.models = {
     getDefaultValue: params => params.defaultExpandedItems
   }
 };
-const DEFAULT_EXPANDED_NODES = [];
+const DEFAULT_EXPANDED_ITEMS = [];
 useTreeViewExpansion.getDefaultizedParams = params => (0, _extends2.default)({}, params, {
-  defaultExpandedItems: params.defaultExpandedItems ?? DEFAULT_EXPANDED_NODES
+  defaultExpandedItems: params.defaultExpandedItems ?? DEFAULT_EXPANDED_ITEMS
 });
 useTreeViewExpansion.params = {
   expandedItems: true,

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

@@ -17,7 +17,7 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 const useTabbableItemId = (instance, selectedItems) => {
   const isItemVisible = itemId => {
     const node = instance.getNode(itemId);
-    return node && (node.parentId == null || instance.isNodeExpanded(node.parentId));
+    return node && (node.parentId == null || instance.isItemExpanded(node.parentId));
   };
   let tabbableItemId;
   if (Array.isArray(selectedItems)) {
@@ -41,18 +41,18 @@ const useTreeViewFocus = ({
 }) => {
   const tabbableItemId = useTabbableItemId(instance, models.selectedItems.value);
   const setFocusedItemId = (0, _useEventCallback.default)(itemId => {
-    const cleanItemId = typeof itemId === 'function' ? itemId(state.focusedNodeId) : itemId;
-    if (state.focusedNodeId !== cleanItemId) {
+    const cleanItemId = typeof itemId === 'function' ? itemId(state.focusedItemId) : itemId;
+    if (state.focusedItemId !== cleanItemId) {
       setState(prevState => (0, _extends2.default)({}, prevState, {
-        focusedNodeId: cleanItemId
+        focusedItemId: cleanItemId
       }));
     }
   });
   const isTreeViewFocused = React.useCallback(() => !!rootRef.current && rootRef.current.contains((0, _utils.getActiveElement)((0, _ownerDocument.default)(rootRef.current))), [rootRef]);
-  const isNodeFocused = React.useCallback(itemId => state.focusedNodeId === itemId && isTreeViewFocused(), [state.focusedNodeId, isTreeViewFocused]);
-  const isNodeVisible = itemId => {
+  const isItemFocused = React.useCallback(itemId => state.focusedItemId === itemId && isTreeViewFocused(), [state.focusedItemId, isTreeViewFocused]);
+  const isItemVisible = itemId => {
     const node = instance.getNode(itemId);
-    return node && (node.parentId == null || instance.isNodeExpanded(node.parentId));
+    return node && (node.parentId == null || instance.isItemExpanded(node.parentId));
   };
   const innerFocusItem = (event, itemId) => {
     const node = instance.getNode(itemId);
@@ -65,62 +65,64 @@ const useTreeViewFocus = ({
       params.onItemFocus(event, itemId);
     }
   };
-  const focusItem = (0, _useEventCallback.default)((event, nodeId) => {
-    // If we receive a nodeId, and it is visible, the focus will be set to it
-    if (isNodeVisible(nodeId)) {
-      innerFocusItem(event, nodeId);
+  const focusItem = (0, _useEventCallback.default)((event, itemId) => {
+    // If we receive an itemId, and it is visible, the focus will be set to it
+    if (isItemVisible(itemId)) {
+      innerFocusItem(event, itemId);
     }
   });
-  const focusDefaultNode = (0, _useEventCallback.default)(event => {
-    let nodeToFocusId;
+  const focusDefaultItem = (0, _useEventCallback.default)(event => {
+    let itemToFocusId;
     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;
+      itemToFocusId = models.selectedItems.value.find(isItemVisible);
+    } else if (models.selectedItems.value != null && isItemVisible(models.selectedItems.value)) {
+      itemToFocusId = models.selectedItems.value;
     }
-    if (nodeToFocusId == null) {
-      nodeToFocusId = instance.getNavigableChildrenIds(null)[0];
+    if (itemToFocusId == null) {
+      itemToFocusId = instance.getNavigableChildrenIds(null)[0];
     }
-    innerFocusItem(event, nodeToFocusId);
+    innerFocusItem(event, itemToFocusId);
   });
   const removeFocusedItem = (0, _useEventCallback.default)(() => {
-    if (state.focusedNodeId == null) {
+    if (state.focusedItemId == null) {
       return;
     }
-    const node = instance.getNode(state.focusedNodeId);
-    const itemElement = document.getElementById(instance.getTreeItemId(state.focusedNodeId, node.idAttribute));
-    if (itemElement) {
-      itemElement.blur();
+    const node = instance.getNode(state.focusedItemId);
+    if (node) {
+      const itemElement = document.getElementById(instance.getTreeItemId(state.focusedItemId, node.idAttribute));
+      if (itemElement) {
+        itemElement.blur();
+      }
     }
     setFocusedItemId(null);
   });
   const canItemBeTabbed = itemId => itemId === tabbableItemId;
   (0, _useTreeView.populateInstance)(instance, {
-    isNodeFocused,
+    isItemFocused,
     canItemBeTabbed,
     focusItem,
-    focusDefaultNode,
+    focusDefaultItem,
     removeFocusedItem
   });
   (0, _useTreeView.populatePublicAPI)(publicAPI, {
     focusItem
   });
-  (0, _useInstanceEventHandler.useInstanceEventHandler)(instance, 'removeNode', ({
+  (0, _useInstanceEventHandler.useInstanceEventHandler)(instance, 'removeItem', ({
     id
   }) => {
-    if (state.focusedNodeId === id) {
-      instance.focusDefaultNode(null);
+    if (state.focusedItemId === id) {
+      instance.focusDefaultItem(null);
     }
   });
   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) {
-      instance.focusDefaultNode(event);
+      instance.focusDefaultItem(event);
     }
   };
-  const focusedNode = instance.getNode(state.focusedNodeId);
-  const activeDescendant = focusedNode ? instance.getTreeItemId(focusedNode.id, focusedNode.idAttribute) : null;
+  const focusedItem = instance.getNode(state.focusedItemId);
+  const activeDescendant = focusedItem ? instance.getTreeItemId(focusedItem.id, focusedItem.idAttribute) : null;
   return {
     getRootProps: otherHandlers => ({
       onFocus: createHandleFocus(otherHandlers),
@@ -130,7 +132,7 @@ const useTreeViewFocus = ({
 };
 exports.useTreeViewFocus = useTreeViewFocus;
 useTreeViewFocus.getInitialState = () => ({
-  focusedNodeId: null
+  focusedItemId: null
 });
 useTreeViewFocus.params = {
   onItemFocus: true

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

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