@mui/x-tree-view 7.0.0-beta.5 → 7.0.0-beta.7

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

@@ -12,13 +12,14 @@ var _useTreeView = require("../../useTreeView/useTreeView.utils");
 var _publishTreeViewEvent = require("../../utils/publishTreeViewEvent");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const updateState = ({
+const updateNodesState = ({
   items,
   isItemDisabled,
   getItemLabel,
   getItemId
 }) => {
   const nodeMap = {};
+  const itemMap = {};
   const processItem = (item, index, parentId) => {
     const id = getItemId ? getItemId(item) : item.id;
     if (id == null) {
@@ -36,10 +37,11 @@ const updateState = ({
       label,
       index,
       parentId,
-      idAttribute: id,
+      idAttribute: undefined,
       expandable: !!item.children?.length,
       disabled: isItemDisabled ? isItemDisabled(item) : false
     };
+    itemMap[id] = item;
     return {
       id,
       children: item.children?.map((child, childIndex) => processItem(child, childIndex, id))
@@ -48,16 +50,19 @@ const updateState = ({
   const nodeTree = items.map((item, itemIndex) => processItem(item, itemIndex, null));
   return {
     nodeMap,
-    nodeTree
+    nodeTree,
+    itemMap
   };
 };
 const useTreeViewNodes = ({
   instance,
+  publicAPI,
   params,
   state,
   setState
 }) => {
-  const getNode = React.useCallback(nodeId => state.nodeMap[nodeId], [state.nodeMap]);
+  const getNode = React.useCallback(nodeId => state.nodes.nodeMap[nodeId], [state.nodes.nodeMap]);
+  const getItem = React.useCallback(nodeId => state.nodes.itemMap[nodeId], [state.nodes.itemMap]);
   const isNodeDisabled = React.useCallback(nodeId => {
     if (nodeId == null) {
       return false;
@@ -79,7 +84,7 @@ const useTreeViewNodes = ({
     }
     return false;
   }, [instance]);
-  const getChildrenIds = (0, _useEventCallback.default)(nodeId => Object.values(state.nodeMap).filter(node => node.parentId === nodeId).sort((a, b) => a.index - b.index).map(child => child.id));
+  const getChildrenIds = (0, _useEventCallback.default)(nodeId => Object.values(state.nodes.nodeMap).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) {
@@ -89,28 +94,30 @@ const useTreeViewNodes = ({
   };
   React.useEffect(() => {
     setState(prevState => {
-      const newState = updateState({
+      const newState = updateNodesState({
         items: params.items,
         isItemDisabled: params.isItemDisabled,
         getItemId: params.getItemId,
         getItemLabel: params.getItemLabel
       });
-      Object.values(prevState.nodeMap).forEach(node => {
+      Object.values(prevState.nodes.nodeMap).forEach(node => {
         if (!newState.nodeMap[node.id]) {
           (0, _publishTreeViewEvent.publishTreeViewEvent)(instance, 'removeNode', {
             id: node.id
           });
         }
       });
-      return (0, _extends2.default)({}, prevState, newState);
+      return (0, _extends2.default)({}, prevState, {
+        nodes: newState
+      });
     });
   }, [instance, setState, params.items, params.isItemDisabled, params.getItemId, params.getItemLabel]);
-  const getNodesToRender = (0, _useEventCallback.default)(() => {
+  const getNodesToRender = () => {
     const getPropsFromNodeId = ({
       id,
       children
     }) => {
-      const node = state.nodeMap[id];
+      const node = state.nodes.nodeMap[id];
       return {
         label: node.label,
         nodeId: node.id,
@@ -118,15 +125,19 @@ const useTreeViewNodes = ({
         children: children?.map(getPropsFromNodeId)
       };
     };
-    return state.nodeTree.map(getPropsFromNodeId);
-  });
+    return state.nodes.nodeTree.map(getPropsFromNodeId);
+  };
   (0, _useTreeView.populateInstance)(instance, {
     getNode,
+    getItem,
     getNodesToRender,
     getChildrenIds,
     getNavigableChildrenIds,
     isNodeDisabled
   });
+  (0, _useTreeView.populatePublicAPI)(publicAPI, {
+    getItem
+  });
   return {
     contextValue: {
       disabledItemsFocusable: params.disabledItemsFocusable
@@ -134,11 +145,13 @@ const useTreeViewNodes = ({
   };
 };
 exports.useTreeViewNodes = useTreeViewNodes;
-useTreeViewNodes.getInitialState = params => updateState({
-  items: params.items,
-  isItemDisabled: params.isItemDisabled,
-  getItemId: params.getItemId,
-  getItemLabel: params.getItemLabel
+useTreeViewNodes.getInitialState = params => ({
+  nodes: updateNodesState({
+    items: params.items,
+    isItemDisabled: params.isItemDisabled,
+    getItemId: params.getItemId,
+    getItemLabel: params.getItemLabel
+  })
 });
 useTreeViewNodes.getDefaultizedParams = params => (0, _extends2.default)({}, params, {
   disabledItemsFocusable: params.disabledItemsFocusable ?? false

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

@@ -19,49 +19,49 @@ const useTreeViewSelection = ({
   const lastSelectedNode = React.useRef(null);
   const lastSelectionWasRange = React.useRef(false);
   const currentRangeSelection = React.useRef([]);
-  const setSelectedNodes = (event, newSelectedNodes) => {
-    if (params.onNodeSelectionToggle) {
+  const setSelectedItems = (event, newSelectedItems) => {
+    if (params.onItemSelectionToggle) {
       if (params.multiSelect) {
-        const addedNodes = newSelectedNodes.filter(nodeId => !instance.isNodeSelected(nodeId));
-        const removedNodes = models.selectedNodes.value.filter(nodeId => !newSelectedNodes.includes(nodeId));
-        addedNodes.forEach(nodeId => {
-          params.onNodeSelectionToggle(event, nodeId, true);
+        const addedItems = newSelectedItems.filter(itemId => !instance.isNodeSelected(itemId));
+        const removedItems = models.selectedItems.value.filter(itemId => !newSelectedItems.includes(itemId));
+        addedItems.forEach(itemId => {
+          params.onItemSelectionToggle(event, itemId, true);
         });
-        removedNodes.forEach(nodeId => {
-          params.onNodeSelectionToggle(event, nodeId, false);
+        removedItems.forEach(itemId => {
+          params.onItemSelectionToggle(event, itemId, false);
         });
-      } else if (newSelectedNodes !== models.selectedNodes.value) {
-        if (models.selectedNodes.value != null) {
-          params.onNodeSelectionToggle(event, models.selectedNodes.value, false);
+      } else if (newSelectedItems !== models.selectedItems.value) {
+        if (models.selectedItems.value != null) {
+          params.onItemSelectionToggle(event, models.selectedItems.value, false);
         }
-        if (newSelectedNodes != null) {
-          params.onNodeSelectionToggle(event, newSelectedNodes, true);
+        if (newSelectedItems != null) {
+          params.onItemSelectionToggle(event, newSelectedItems, true);
         }
       }
     }
-    if (params.onSelectedNodesChange) {
-      params.onSelectedNodesChange(event, newSelectedNodes);
+    if (params.onSelectedItemsChange) {
+      params.onSelectedItemsChange(event, newSelectedItems);
     }
-    models.selectedNodes.setControlledValue(newSelectedNodes);
+    models.selectedItems.setControlledValue(newSelectedItems);
   };
-  const isNodeSelected = nodeId => Array.isArray(models.selectedNodes.value) ? models.selectedNodes.value.indexOf(nodeId) !== -1 : models.selectedNodes.value === nodeId;
+  const isNodeSelected = nodeId => Array.isArray(models.selectedItems.value) ? models.selectedItems.value.indexOf(nodeId) !== -1 : models.selectedItems.value === nodeId;
   const selectNode = (event, nodeId, multiple = false) => {
     if (params.disableSelection) {
       return;
     }
     if (multiple) {
-      if (Array.isArray(models.selectedNodes.value)) {
+      if (Array.isArray(models.selectedItems.value)) {
         let newSelected;
-        if (models.selectedNodes.value.indexOf(nodeId) !== -1) {
-          newSelected = models.selectedNodes.value.filter(id => id !== nodeId);
+        if (models.selectedItems.value.indexOf(nodeId) !== -1) {
+          newSelected = models.selectedItems.value.filter(id => id !== nodeId);
         } else {
-          newSelected = [nodeId].concat(models.selectedNodes.value);
+          newSelected = [nodeId].concat(models.selectedItems.value);
         }
-        setSelectedNodes(event, newSelected);
+        setSelectedItems(event, newSelected);
       }
     } else {
       const newSelected = params.multiSelect ? [nodeId] : nodeId;
-      setSelectedNodes(event, newSelected);
+      setSelectedItems(event, newSelected);
     }
     lastSelectedNode.current = nodeId;
     lastSelectionWasRange.current = false;
@@ -78,7 +78,7 @@ const useTreeViewSelection = ({
     return nodes;
   };
   const handleRangeArrowSelect = (event, nodes) => {
-    let base = models.selectedNodes.value.slice();
+    let base = models.selectedItems.value.slice();
     const {
       start,
       next,
@@ -102,10 +102,10 @@ const useTreeViewSelection = ({
       base.push(next);
       currentRangeSelection.current.push(current, next);
     }
-    setSelectedNodes(event, base);
+    setSelectedItems(event, base);
   };
   const handleRangeSelect = (event, nodes) => {
-    let base = models.selectedNodes.value.slice();
+    let base = models.selectedItems.value.slice();
     const {
       start,
       end
@@ -119,7 +119,7 @@ const useTreeViewSelection = ({
     currentRangeSelection.current = range;
     let newSelected = base.concat(range);
     newSelected = newSelected.filter((id, i) => newSelected.indexOf(id) === i);
-    setSelectedNodes(event, newSelected);
+    setSelectedItems(event, newSelected);
   };
   const selectRange = (event, nodes, stacked = false) => {
     if (params.disableSelection) {
@@ -184,21 +184,21 @@ const useTreeViewSelection = ({
 };
 exports.useTreeViewSelection = useTreeViewSelection;
 useTreeViewSelection.models = {
-  selectedNodes: {
-    getDefaultValue: params => params.defaultSelectedNodes
+  selectedItems: {
+    getDefaultValue: params => params.defaultSelectedItems
   }
 };
 const DEFAULT_SELECTED_NODES = [];
 useTreeViewSelection.getDefaultizedParams = params => (0, _extends2.default)({}, params, {
   disableSelection: params.disableSelection ?? false,
   multiSelect: params.multiSelect ?? false,
-  defaultSelectedNodes: params.defaultSelectedNodes ?? (params.multiSelect ? DEFAULT_SELECTED_NODES : null)
+  defaultSelectedItems: params.defaultSelectedItems ?? (params.multiSelect ? DEFAULT_SELECTED_NODES : null)
 });
 useTreeViewSelection.params = {
   disableSelection: true,
   multiSelect: true,
-  defaultSelectedNodes: true,
-  selectedNodes: true,
-  onSelectedNodesChange: true,
-  onNodeSelectionToggle: true
+  defaultSelectedItems: true,
+  selectedItems: true,
+  onSelectedItemsChange: true,
+  onItemSelectionToggle: true
 };

package/node/internals/useTreeView/useTreeView.js

@@ -48,6 +48,7 @@ const useTreeView = inParams => {
   });
   const rootPropsGetters = [];
   const contextValue = {
+    publicAPI,
     instance: instance
   };
   const runPlugin = plugin => {
@@ -70,43 +71,44 @@ const useTreeView = inParams => {
     }
   };
   plugins.forEach(runPlugin);
-  contextValue.runItemPlugins = ({
-    props,
-    ref
-  }) => {
-    let finalProps = props;
-    let finalRef = ref;
-    const itemWrappers = [];
+  contextValue.runItemPlugins = itemPluginProps => {
+    let finalRootRef = null;
+    let finalContentRef = null;
     plugins.forEach(plugin => {
       if (!plugin.itemPlugin) {
         return;
       }
       const itemPluginResponse = plugin.itemPlugin({
-        props: finalProps,
-        ref: finalRef
+        props: itemPluginProps,
+        rootRef: finalRootRef,
+        contentRef: finalContentRef
       });
-      if (itemPluginResponse?.props) {
-        finalProps = itemPluginResponse.props;
-      }
-      if (itemPluginResponse?.ref) {
-        finalRef = itemPluginResponse.ref;
+      if (itemPluginResponse?.rootRef) {
+        finalRootRef = itemPluginResponse.rootRef;
       }
-      if (itemPluginResponse?.wrapItem) {
-        itemWrappers.push(itemPluginResponse.wrapItem);
+      if (itemPluginResponse?.contentRef) {
+        finalContentRef = itemPluginResponse.contentRef;
       }
     });
     return {
-      props: finalProps,
-      ref: finalRef,
-      wrapItem: children => {
-        let finalChildren = children;
-        itemWrappers.forEach(itemWrapper => {
-          finalChildren = itemWrapper(finalChildren);
-        });
-        return finalChildren;
-      }
+      contentRef: finalContentRef,
+      rootRef: finalRootRef
     };
   };
+  const itemWrappers = plugins.map(plugin => plugin.wrapItem).filter(wrapItem => !!wrapItem);
+  contextValue.wrapItem = ({
+    nodeId,
+    children
+  }) => {
+    let finalChildren = children;
+    itemWrappers.forEach(itemWrapper => {
+      finalChildren = itemWrapper({
+        nodeId,
+        children: finalChildren
+      });
+    });
+    return finalChildren;
+  };
   const getRootProps = (otherHandlers = {}) => {
     const rootProps = (0, _extends2.default)({
       role: 'tree',

package/node/useTreeItem2/index.js

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

package/node/useTreeItem2/useTreeItem2.js

@@ -0,0 +1,143 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeItem2 = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _utils = require("@mui/base/utils");
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _useTreeViewContext = require("../internals/TreeViewProvider/useTreeViewContext");
+var _useTreeItem2Utils = require("../hooks/useTreeItem2Utils");
+const useTreeItem2 = parameters => {
+  const {
+    runItemPlugins,
+    selection: {
+      multiSelect
+    },
+    disabledItemsFocusable,
+    instance,
+    publicAPI
+  } = (0, _useTreeViewContext.useTreeViewContext)();
+  const {
+    id,
+    nodeId,
+    label,
+    children,
+    rootRef
+  } = parameters;
+  const {
+    rootRef: pluginRootRef,
+    contentRef
+  } = runItemPlugins(parameters);
+  const {
+    interactions,
+    status
+  } = (0, _useTreeItem2Utils.useTreeItem2Utils)({
+    nodeId,
+    children
+  });
+  const idAttribute = instance.getTreeItemId(nodeId, id);
+  const handleRootRef = (0, _useForkRef.default)(rootRef, pluginRootRef);
+  const createRootHandleFocus = otherHandlers => event => {
+    otherHandlers.onFocus?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+
+    // DOM focus stays on the tree which manages focus with aria-activedescendant
+    if (event.target === event.currentTarget) {
+      instance.focusRoot();
+    }
+    const canBeFocused = !status.disabled || disabledItemsFocusable;
+    if (!status.focused && canBeFocused && event.currentTarget === event.target) {
+      instance.focusItem(event, nodeId);
+    }
+  };
+  const createContentHandleClick = otherHandlers => event => {
+    otherHandlers.onClick?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    interactions.handleExpansion(event);
+    interactions.handleSelection(event);
+  };
+  const createContentHandleMouseDown = otherHandlers => event => {
+    otherHandlers.onMouseDown?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+
+    // Prevent text selection
+    if (event.shiftKey || event.ctrlKey || event.metaKey || status.disabled) {
+      event.preventDefault();
+    }
+  };
+  const getRootProps = (externalProps = {}) => {
+    const externalEventHandlers = (0, _extends2.default)({}, (0, _utils.extractEventHandlers)(parameters), (0, _utils.extractEventHandlers)(externalProps));
+    let ariaSelected;
+    if (multiSelect) {
+      ariaSelected = status.selected;
+    } else if (status.selected) {
+      /* single-selection trees unset aria-selected on un-selected items.
+       *
+       * If the tree does not support multiple selection, aria-selected
+       * is set to true for the selected node and it is not present on any other node in the tree.
+       * Source: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/
+       */
+      ariaSelected = true;
+    }
+    return (0, _extends2.default)({}, externalEventHandlers, {
+      ref: handleRootRef,
+      role: 'treeitem',
+      tabIndex: -1,
+      id: idAttribute,
+      'aria-expanded': status.expandable ? status.expanded : undefined,
+      'aria-selected': ariaSelected,
+      'aria-disabled': status.disabled || undefined
+    }, externalProps, {
+      onFocus: createRootHandleFocus(externalEventHandlers)
+    });
+  };
+  const getContentProps = (externalProps = {}) => {
+    const externalEventHandlers = (0, _extends2.default)({}, (0, _utils.extractEventHandlers)(parameters), (0, _utils.extractEventHandlers)(externalProps));
+    return (0, _extends2.default)({}, externalEventHandlers, externalProps, {
+      ref: contentRef,
+      onClick: createContentHandleClick(externalEventHandlers),
+      onMouseDown: createContentHandleMouseDown(externalEventHandlers),
+      status
+    });
+  };
+  const getLabelProps = (externalProps = {}) => {
+    const externalEventHandlers = (0, _extends2.default)({}, (0, _utils.extractEventHandlers)(parameters), (0, _utils.extractEventHandlers)(externalProps));
+    return (0, _extends2.default)({}, externalEventHandlers, {
+      children: label
+    }, externalProps);
+  };
+  const getIconContainerProps = (externalProps = {}) => {
+    const externalEventHandlers = (0, _extends2.default)({}, (0, _utils.extractEventHandlers)(parameters), (0, _utils.extractEventHandlers)(externalProps));
+    return (0, _extends2.default)({}, externalEventHandlers, externalProps);
+  };
+  const getGroupTransitionProps = (externalProps = {}) => {
+    const externalEventHandlers = (0, _extends2.default)({}, (0, _utils.extractEventHandlers)(parameters), (0, _utils.extractEventHandlers)(externalProps));
+    return (0, _extends2.default)({}, externalEventHandlers, {
+      unmountOnExit: true,
+      component: 'ul',
+      role: 'group',
+      in: status.expanded,
+      children
+    }, externalProps);
+  };
+  return {
+    getRootProps,
+    getContentProps,
+    getGroupTransitionProps,
+    getIconContainerProps,
+    getLabelProps,
+    rootRef: handleRootRef,
+    status,
+    publicAPI
+  };
+};
+exports.useTreeItem2 = useTreeItem2;

package/node/useTreeItem2/useTreeItem2.types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-tree-view",
-  "version": "7.0.0-beta.5",
+  "version": "7.0.0-beta.7",
   "description": "The community edition of the tree view components (MUI X).",
   "author": "MUI Team",
   "main": "./node/index.js",
@@ -32,7 +32,7 @@
     "directory": "packages/x-tree-view"
   },
   "dependencies": {
-    "@babel/runtime": "^7.23.9",
+    "@babel/runtime": "^7.24.0",
     "@mui/base": "^5.0.0-beta.36",
     "@mui/system": "^5.15.9",
     "@mui/utils": "^5.15.9",

package/themeAugmentation/components.d.ts

@@ -21,6 +21,11 @@ export interface TreeViewComponents<Theme = unknown> {
     styleOverrides?: ComponentsOverrides<Theme>['MuiTreeItem'];
     variants?: ComponentsVariants<Theme>['MuiTreeItem'];
   };
+  MuiTreeItem2?: {
+    defaultProps?: ComponentsProps['MuiTreeItem2'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiTreeItem2'];
+    variants?: ComponentsVariants<Theme>['MuiTreeItem2'];
+  };
 }
 
 declare module '@mui/material/styles' {

package/themeAugmentation/overrides.d.ts

@@ -9,6 +9,7 @@ export interface TreeViewComponentNameToClassKey {
   MuiRichTreeView: RichTreeViewClassKey;
   MuiTreeView: TreeViewClassKey;
   MuiTreeItem: TreeItemClassKey;
+  MuiTreeItem2: TreeItemClassKey;
 }
 
 declare module '@mui/material/styles' {

package/themeAugmentation/props.d.ts

@@ -2,12 +2,14 @@ import { TreeItemProps } from '../TreeItem';
 import { TreeViewProps } from '../TreeView';
 import { SimpleTreeViewProps } from '../SimpleTreeView';
 import { RichTreeViewProps } from '../RichTreeView';
+import { TreeItem2Props } from '../TreeItem2';
 
 export interface TreeViewComponentsPropsList {
   MuiSimpleTreeView: SimpleTreeViewProps<any>;
   MuiRichTreeView: RichTreeViewProps<any, any>;
   MuiTreeView: TreeViewProps<any>;
   MuiTreeItem: TreeItemProps;
+  MuiTreeItem2: TreeItem2Props;
 }
 
 declare module '@mui/material/styles' {

package/useTreeItem2/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeItem2 as unstable_useTreeItem2 } from './useTreeItem2';
+export type { UseTreeItem2Parameters, UseTreeItem2ReturnValue, UseTreeItem2Status, UseTreeItem2ContentSlotOwnProps, } from './useTreeItem2.types';

package/useTreeItem2/index.js

@@ -0,0 +1 @@
+export { useTreeItem2 as unstable_useTreeItem2 } from './useTreeItem2';

package/useTreeItem2/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/useTreeItem2/index.js",
+  "types": "./index.d.ts"
+}

package/useTreeItem2/useTreeItem2.d.ts

@@ -0,0 +1,2 @@
+import { UseTreeItem2Parameters, UseTreeItem2ReturnValue } from './useTreeItem2.types';
+export declare const useTreeItem2: <TPlugins extends [import("../internals").UseTreeViewIdSignature, import("../internals").UseTreeViewNodesSignature, import("../internals").UseTreeViewExpansionSignature, import("../internals").UseTreeViewSelectionSignature, import("../internals").UseTreeViewFocusSignature, import("../internals").UseTreeViewKeyboardNavigationSignature, import("../internals").UseTreeViewIconsSignature] = [import("../internals").UseTreeViewIdSignature, import("../internals").UseTreeViewNodesSignature, import("../internals").UseTreeViewExpansionSignature, import("../internals").UseTreeViewSelectionSignature, import("../internals").UseTreeViewFocusSignature, import("../internals").UseTreeViewKeyboardNavigationSignature, import("../internals").UseTreeViewIconsSignature]>(parameters: UseTreeItem2Parameters) => UseTreeItem2ReturnValue<TPlugins>;