@mui/x-tree-view 7.0.0 → 7.1.0

package/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/internals/plugins/useTreeViewSelection/useTreeViewSelection.types.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import type { DefaultizedProps, TreeViewItemRange, TreeViewPluginSignature } from '../../models';
-import { UseTreeViewNodesSignature } from '../useTreeViewNodes';
+import { UseTreeViewItemsSignature } from '../useTreeViewItems';
 import { UseTreeViewExpansionSignature } from '../useTreeViewExpansion';
 export interface UseTreeViewSelectionInstance {
-    isNodeSelected: (itemId: string) => boolean;
-    selectNode: (event: React.SyntheticEvent, itemId: string, multiple?: boolean) => void;
-    selectRange: (event: React.SyntheticEvent, nodes: TreeViewItemRange, stacked?: boolean) => void;
+    isItemSelected: (itemId: string) => boolean;
+    selectItem: (event: React.SyntheticEvent, itemId: string, multiple?: boolean) => void;
+    selectRange: (event: React.SyntheticEvent, items: TreeViewItemRange, stacked?: boolean) => void;
     rangeSelectToFirst: (event: React.KeyboardEvent, itemId: string) => void;
     rangeSelectToLast: (event: React.KeyboardEvent, itemId: string) => void;
 }
@@ -58,9 +58,9 @@ export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
     contextValue: UseTreeViewSelectionContextValue;
     modelNames: 'selectedItems';
     dependantPlugins: [
-        UseTreeViewNodesSignature,
+        UseTreeViewItemsSignature,
         UseTreeViewExpansionSignature,
-        UseTreeViewNodesSignature
+        UseTreeViewItemsSignature
     ];
 }>;
 export {};

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.utils.d.ts

@@ -1,17 +1,17 @@
 import { TreeViewInstance } from '../../models';
-import { UseTreeViewNodesSignature } from '../useTreeViewNodes';
+import { UseTreeViewItemsSignature } from '../useTreeViewItems';
 /**
  * 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 declare const findOrderInTremauxTree: (instance: TreeViewInstance<[UseTreeViewNodesSignature]>, nodeAId: string, nodeBId: string) => string[];
+export declare const findOrderInTremauxTree: (instance: TreeViewInstance<[UseTreeViewItemsSignature]>, nodeAId: string, nodeBId: string) => string[];

package/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/internals/useTreeView/useTreeView.utils.d.ts

@@ -1,9 +1,9 @@
 import { TreeViewAnyPluginSignature, TreeViewInstance, TreeViewUsedInstance, TreeViewUsedPublicAPI } from '../models';
 import type { UseTreeViewExpansionSignature } from '../plugins/useTreeViewExpansion';
-import type { UseTreeViewNodesSignature } from '../plugins/useTreeViewNodes';
-export declare const getPreviousNode: (instance: TreeViewInstance<[UseTreeViewNodesSignature, UseTreeViewExpansionSignature]>, itemId: string) => string | null;
-export declare const getNextNode: (instance: TreeViewInstance<[UseTreeViewExpansionSignature, UseTreeViewNodesSignature]>, itemId: string) => string | null;
-export declare const getLastNode: (instance: TreeViewInstance<[UseTreeViewExpansionSignature, UseTreeViewNodesSignature]>) => string;
-export declare const getFirstNode: (instance: TreeViewInstance<[UseTreeViewNodesSignature]>) => string;
+import type { UseTreeViewItemsSignature } from '../plugins/useTreeViewItems';
+export declare const getPreviousItem: (instance: TreeViewInstance<[UseTreeViewItemsSignature, UseTreeViewExpansionSignature]>, itemId: string) => string | null;
+export declare const getNextItem: (instance: TreeViewInstance<[UseTreeViewExpansionSignature, UseTreeViewItemsSignature]>, itemId: string) => string | null;
+export declare const getLastItem: (instance: TreeViewInstance<[UseTreeViewExpansionSignature, UseTreeViewItemsSignature]>) => string;
+export declare const getFirstItem: (instance: TreeViewInstance<[UseTreeViewItemsSignature]>) => string;
 export declare const populateInstance: <T extends TreeViewAnyPluginSignature>(instance: TreeViewUsedInstance<T>, methods: T["instance"]) => void;
 export declare const populatePublicAPI: <T extends TreeViewAnyPluginSignature>(publicAPI: TreeViewUsedPublicAPI<T>, methods: T["publicAPI"]) => void;

package/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/modern/RichTreeView/RichTreeView.js

@@ -104,8 +104,8 @@ const RichTreeView = /*#__PURE__*/React.forwardRef(function RichTreeView(inProps
     getSlotProps: getRootProps,
     ownerState: props
   });
-  const nodesToRender = instance.getNodesToRender();
-  const renderNode = ({
+  const itemsToRender = instance.getItemsToRender();
+  const renderItem = ({
     label,
     itemId,
     id,
@@ -117,13 +117,13 @@ const RichTreeView = /*#__PURE__*/React.forwardRef(function RichTreeView(inProps
       label: label,
       id: id,
       itemId: itemId,
-      children: children?.map(renderNode)
+      children: children?.map(renderItem)
     }, itemId);
   };
   return /*#__PURE__*/_jsx(TreeViewProvider, {
     value: contextValue,
     children: /*#__PURE__*/_jsx(Root, _extends({}, rootProps, {
-      children: nodesToRender.map(renderNode)
+      children: itemsToRender.map(renderItem)
     }))
   });
 });

package/modern/SimpleTreeView/SimpleTreeView.plugins.js

@@ -1,5 +1,5 @@
 import { DEFAULT_TREE_VIEW_PLUGINS } from '../internals/plugins/defaultPlugins';
-import { useTreeViewJSXNodes } from '../internals/plugins/useTreeViewJSXNodes';
-export const SIMPLE_TREE_VIEW_PLUGINS = [...DEFAULT_TREE_VIEW_PLUGINS, useTreeViewJSXNodes];
+import { useTreeViewJSXItems } from '../internals/plugins/useTreeViewJSXItems';
+export const SIMPLE_TREE_VIEW_PLUGINS = [...DEFAULT_TREE_VIEW_PLUGINS, useTreeViewJSXItems];
 
 // We can't infer this type from the plugin, otherwise we would lose the generics.

package/modern/TreeItem/TreeItem.js

@@ -186,10 +186,10 @@ export const TreeItem = /*#__PURE__*/React.forwardRef(function TreeItem(inProps,
     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 = _extends({}, props, {
     expanded,
     focused,

package/modern/TreeItem/useTreeItemState.js

@@ -6,11 +6,11 @@ export function useTreeItemState(itemId) {
       multiSelect
     }
   } = 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) {
@@ -19,8 +19,8 @@ export 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);
       }
     }
   };
@@ -36,10 +36,10 @@ export 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/modern/hooks/useTreeItem2Utils/useTreeItem2Utils.js

@@ -11,10 +11,10 @@ export const useTreeItem2Utils = ({
   } = 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) {
@@ -26,8 +26,8 @@ export 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 => {
@@ -44,10 +44,10 @@ export 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/modern/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/modern/internals/TreeViewProvider/DescendantProvider.js

@@ -46,7 +46,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/modern/internals/plugins/defaultPlugins.js

@@ -1,10 +1,10 @@
 import { useTreeViewId } from './useTreeViewId';
-import { useTreeViewNodes } from './useTreeViewNodes';
+import { useTreeViewItems } from './useTreeViewItems';
 import { useTreeViewExpansion } from './useTreeViewExpansion';
 import { useTreeViewSelection } from './useTreeViewSelection';
 import { useTreeViewFocus } from './useTreeViewFocus';
 import { useTreeViewKeyboardNavigation } from './useTreeViewKeyboardNavigation';
 import { useTreeViewIcons } from './useTreeViewIcons';
-export const DEFAULT_TREE_VIEW_PLUGINS = [useTreeViewId, useTreeViewNodes, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewIcons];
+export const DEFAULT_TREE_VIEW_PLUGINS = [useTreeViewId, useTreeViewItems, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewIcons];
 
 // We can't infer this type from the plugin, otherwise we would lose the generics.

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

@@ -11,11 +11,11 @@ export 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 = useEventCallback((event, itemId) => {
+  const isItemExpandable = React.useCallback(itemId => !!instance.getNode(itemId)?.expandable, [instance]);
+  const toggleItemExpansion = useEventCallback((event, itemId) => {
     if (itemId == null) {
       return;
     }
@@ -34,7 +34,7 @@ export 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) {
@@ -46,9 +46,9 @@ export const useTreeViewExpansion = ({
     }
   };
   populateInstance(instance, {
-    isNodeExpanded,
-    isNodeExpandable,
-    toggleNodeExpansion,
+    isItemExpanded,
+    isItemExpandable,
+    toggleItemExpansion,
     expandAllSiblings
   });
 };
@@ -57,9 +57,9 @@ useTreeViewExpansion.models = {
     getDefaultValue: params => params.defaultExpandedItems
   }
 };
-const DEFAULT_EXPANDED_NODES = [];
+const DEFAULT_EXPANDED_ITEMS = [];
 useTreeViewExpansion.getDefaultizedParams = params => _extends({}, params, {
-  defaultExpandedItems: params.defaultExpandedItems ?? DEFAULT_EXPANDED_NODES
+  defaultExpandedItems: params.defaultExpandedItems ?? DEFAULT_EXPANDED_ITEMS
 });
 useTreeViewExpansion.params = {
   expandedItems: true,