@mui/x-tree-view 7.0.0-beta.6 → 7.0.0

package/node/internals/useTreeView/useTreeView.utils.js

@@ -4,46 +4,46 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.populatePublicAPI = exports.populateInstance = exports.getPreviousNode = exports.getNextNode = exports.getLastNode = exports.getFirstNode = void 0;
-const getPreviousNode = (instance, nodeId) => {
-  const node = instance.getNode(nodeId);
-  const siblings = instance.getNavigableChildrenIds(node.parentId);
-  const nodeIndex = siblings.indexOf(nodeId);
-  if (nodeIndex === 0) {
-    return node.parentId;
+const getPreviousNode = (instance, itemId) => {
+  const item = instance.getNode(itemId);
+  const siblings = instance.getNavigableChildrenIds(item.parentId);
+  const itemIndex = siblings.indexOf(itemId);
+  if (itemIndex === 0) {
+    return item.parentId;
   }
-  let currentNode = siblings[nodeIndex - 1];
-  while (instance.isNodeExpanded(currentNode) && instance.getNavigableChildrenIds(currentNode).length > 0) {
-    currentNode = instance.getNavigableChildrenIds(currentNode).pop();
+  let currentItem = siblings[itemIndex - 1];
+  while (instance.isNodeExpanded(currentItem) && instance.getNavigableChildrenIds(currentItem).length > 0) {
+    currentItem = instance.getNavigableChildrenIds(currentItem).pop();
   }
-  return currentNode;
+  return currentItem;
 };
 exports.getPreviousNode = getPreviousNode;
-const getNextNode = (instance, nodeId) => {
+const getNextNode = (instance, itemId) => {
   // If expanded get first child
-  if (instance.isNodeExpanded(nodeId) && instance.getNavigableChildrenIds(nodeId).length > 0) {
-    return instance.getNavigableChildrenIds(nodeId)[0];
+  if (instance.isNodeExpanded(itemId) && instance.getNavigableChildrenIds(itemId).length > 0) {
+    return instance.getNavigableChildrenIds(itemId)[0];
   }
-  let node = instance.getNode(nodeId);
-  while (node != null) {
+  let item = instance.getNode(itemId);
+  while (item != null) {
     // Try to get next sibling
-    const siblings = instance.getNavigableChildrenIds(node.parentId);
-    const nextSibling = siblings[siblings.indexOf(node.id) + 1];
+    const siblings = instance.getNavigableChildrenIds(item.parentId);
+    const nextSibling = siblings[siblings.indexOf(item.id) + 1];
     if (nextSibling) {
       return nextSibling;
     }
 
     // If the sibling does not exist, go up a level to the parent and try again.
-    node = instance.getNode(node.parentId);
+    item = instance.getNode(item.parentId);
   }
   return null;
 };
 exports.getNextNode = getNextNode;
 const getLastNode = instance => {
-  let lastNode = instance.getNavigableChildrenIds(null).pop();
-  while (instance.isNodeExpanded(lastNode)) {
-    lastNode = instance.getNavigableChildrenIds(lastNode).pop();
+  let lastItem = instance.getNavigableChildrenIds(null).pop();
+  while (instance.isNodeExpanded(lastItem)) {
+    lastItem = instance.getNavigableChildrenIds(lastItem).pop();
   }
-  return lastNode;
+  return lastItem;
 };
 exports.getLastNode = getLastNode;
 const getFirstNode = instance => instance.getNavigableChildrenIds(null)[0];

package/node/internals/utils/utils.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getActiveElement = void 0;
+// https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
 const getActiveElement = (root = document) => {
   const activeEl = root.activeElement;
   if (!activeEl) {

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,154 @@
+"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,
+    itemId,
+    label,
+    children,
+    rootRef
+  } = parameters;
+  const {
+    rootRef: pluginRootRef,
+    contentRef
+  } = runItemPlugins(parameters);
+  const {
+    interactions,
+    status
+  } = (0, _useTreeItem2Utils.useTreeItem2Utils)({
+    itemId,
+    children
+  });
+  const idAttribute = instance.getTreeItemId(itemId, id);
+  const handleRootRef = (0, _useForkRef.default)(rootRef, pluginRootRef);
+  const createRootHandleFocus = otherHandlers => event => {
+    otherHandlers.onFocus?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    const canBeFocused = !status.disabled || disabledItemsFocusable;
+    if (!status.focused && canBeFocused && event.currentTarget === event.target) {
+      instance.focusItem(event, itemId);
+    }
+  };
+  const createRootHandleBlur = otherHandlers => event => {
+    otherHandlers.onBlur?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    instance.removeFocusedItem();
+  };
+  const createRootHandleKeyDown = otherHandlers => event => {
+    otherHandlers.onKeyDown?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    instance.handleItemKeyDown(event, itemId);
+  };
+  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 item and it is not present on any other item 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: instance.canItemBeTabbed(itemId) ? 0 : -1,
+      id: idAttribute,
+      'aria-expanded': status.expandable ? status.expanded : undefined,
+      'aria-selected': ariaSelected,
+      'aria-disabled': status.disabled || undefined
+    }, externalProps, {
+      onFocus: createRootHandleFocus(externalEventHandlers),
+      onBlur: createRootHandleBlur(externalEventHandlers),
+      onKeyDown: createRootHandleKeyDown(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.6",
+  "version": "7.0.0",
   "description": "The community edition of the tree view components (MUI X).",
   "author": "MUI Team",
   "main": "./node/index.js",
@@ -33,9 +33,9 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.24.0",
-    "@mui/base": "^5.0.0-beta.36",
-    "@mui/system": "^5.15.9",
-    "@mui/utils": "^5.15.9",
+    "@mui/base": "^5.0.0-beta.40",
+    "@mui/system": "^5.15.14",
+    "@mui/utils": "^5.15.14",
     "@types/react-transition-group": "^4.4.10",
     "clsx": "^2.1.0",
     "prop-types": "^15.8.1",
@@ -44,7 +44,7 @@
   "peerDependencies": {
     "@emotion/react": "^11.9.0",
     "@emotion/styled": "^11.8.1",
-    "@mui/material": "^5.15.0",
+    "@mui/material": "^5.15.14",
     "react": "^17.0.0 || ^18.0.0",
     "react-dom": "^17.0.0 || ^18.0.0"
   },

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>;

package/useTreeItem2/useTreeItem2.js

@@ -0,0 +1,146 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { extractEventHandlers } from '@mui/base/utils';
+import useForkRef from '@mui/utils/useForkRef';
+import { useTreeViewContext } from '../internals/TreeViewProvider/useTreeViewContext';
+import { useTreeItem2Utils } from '../hooks/useTreeItem2Utils';
+export const useTreeItem2 = parameters => {
+  const {
+    runItemPlugins,
+    selection: {
+      multiSelect
+    },
+    disabledItemsFocusable,
+    instance,
+    publicAPI
+  } = useTreeViewContext();
+  const {
+    id,
+    itemId,
+    label,
+    children,
+    rootRef
+  } = parameters;
+  const {
+    rootRef: pluginRootRef,
+    contentRef
+  } = runItemPlugins(parameters);
+  const {
+    interactions,
+    status
+  } = useTreeItem2Utils({
+    itemId,
+    children
+  });
+  const idAttribute = instance.getTreeItemId(itemId, id);
+  const handleRootRef = useForkRef(rootRef, pluginRootRef);
+  const createRootHandleFocus = otherHandlers => event => {
+    otherHandlers.onFocus?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    const canBeFocused = !status.disabled || disabledItemsFocusable;
+    if (!status.focused && canBeFocused && event.currentTarget === event.target) {
+      instance.focusItem(event, itemId);
+    }
+  };
+  const createRootHandleBlur = otherHandlers => event => {
+    otherHandlers.onBlur?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    instance.removeFocusedItem();
+  };
+  const createRootHandleKeyDown = otherHandlers => event => {
+    otherHandlers.onKeyDown?.(event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    instance.handleItemKeyDown(event, itemId);
+  };
+  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 = _extends({}, extractEventHandlers(parameters), 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 item and it is not present on any other item in the tree.
+       * Source: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/
+       */
+      ariaSelected = true;
+    }
+    return _extends({}, externalEventHandlers, {
+      ref: handleRootRef,
+      role: 'treeitem',
+      tabIndex: instance.canItemBeTabbed(itemId) ? 0 : -1,
+      id: idAttribute,
+      'aria-expanded': status.expandable ? status.expanded : undefined,
+      'aria-selected': ariaSelected,
+      'aria-disabled': status.disabled || undefined
+    }, externalProps, {
+      onFocus: createRootHandleFocus(externalEventHandlers),
+      onBlur: createRootHandleBlur(externalEventHandlers),
+      onKeyDown: createRootHandleKeyDown(externalEventHandlers)
+    });
+  };
+  const getContentProps = (externalProps = {}) => {
+    const externalEventHandlers = _extends({}, extractEventHandlers(parameters), extractEventHandlers(externalProps));
+    return _extends({}, externalEventHandlers, externalProps, {
+      ref: contentRef,
+      onClick: createContentHandleClick(externalEventHandlers),
+      onMouseDown: createContentHandleMouseDown(externalEventHandlers),
+      status
+    });
+  };
+  const getLabelProps = (externalProps = {}) => {
+    const externalEventHandlers = _extends({}, extractEventHandlers(parameters), extractEventHandlers(externalProps));
+    return _extends({}, externalEventHandlers, {
+      children: label
+    }, externalProps);
+  };
+  const getIconContainerProps = (externalProps = {}) => {
+    const externalEventHandlers = _extends({}, extractEventHandlers(parameters), extractEventHandlers(externalProps));
+    return _extends({}, externalEventHandlers, externalProps);
+  };
+  const getGroupTransitionProps = (externalProps = {}) => {
+    const externalEventHandlers = _extends({}, extractEventHandlers(parameters), extractEventHandlers(externalProps));
+    return _extends({}, externalEventHandlers, {
+      unmountOnExit: true,
+      component: 'ul',
+      role: 'group',
+      in: status.expanded,
+      children
+    }, externalProps);
+  };
+  return {
+    getRootProps,
+    getContentProps,
+    getGroupTransitionProps,
+    getIconContainerProps,
+    getLabelProps,
+    rootRef: handleRootRef,
+    status,
+    publicAPI
+  };
+};

package/useTreeItem2/useTreeItem2.types.d.ts

@@ -0,0 +1,115 @@
+import * as React from 'react';
+import { TreeViewItemId } from '../models';
+import { MuiCancellableEventHandler } from '../internals/models/MuiCancellableEvent';
+import { TreeViewAnyPluginSignature, TreeViewPublicAPI } from '../internals/models';
+export interface UseTreeItem2Parameters {
+    /**
+     * The id attribute of the item. If not provided, it will be generated.
+     */
+    id?: string;
+    /**
+     * If `true`, the item is disabled.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * The id of the item.
+     * Must be unique.
+     */
+    itemId: TreeViewItemId;
+    /**
+     * The label of the item.
+     */
+    label?: React.ReactNode;
+    rootRef?: React.Ref<HTMLLIElement>;
+    /**
+     * The content of the component.
+     */
+    children?: React.ReactNode;
+}
+export interface UseTreeItem2RootSlotOwnProps {
+    role: 'treeitem';
+    tabIndex: 0 | -1;
+    id: string;
+    'aria-expanded': React.AriaAttributes['aria-expanded'];
+    'aria-selected': React.AriaAttributes['aria-selected'];
+    'aria-disabled': React.AriaAttributes['aria-disabled'];
+    onFocus: MuiCancellableEventHandler<React.FocusEvent<HTMLElement>>;
+    onBlur: MuiCancellableEventHandler<React.FocusEvent<HTMLElement>>;
+    onKeyDown: MuiCancellableEventHandler<React.KeyboardEvent<HTMLElement>>;
+    ref: React.RefCallback<HTMLLIElement>;
+}
+export type UseTreeItem2RootSlotProps<ExternalProps = {}> = ExternalProps & UseTreeItem2RootSlotOwnProps;
+export interface UseTreeItem2ContentSlotOwnProps {
+    onClick: MuiCancellableEventHandler<React.MouseEvent>;
+    onMouseDown: MuiCancellableEventHandler<React.MouseEvent>;
+    ref: React.RefCallback<HTMLDivElement> | null;
+    status: UseTreeItem2Status;
+}
+export type UseTreeItem2ContentSlotProps<ExternalProps = {}> = ExternalProps & UseTreeItem2ContentSlotOwnProps;
+export interface UseTreeItem2IconContainerSlotOwnProps {
+}
+export type UseTreeItemIconContainerSlotProps<ExternalProps = {}> = ExternalProps & UseTreeItem2IconContainerSlotOwnProps;
+export interface UseTreeItem2LabelSlotOwnProps {
+    children: React.ReactNode;
+}
+export type UseTreeItem2LabelSlotProps<ExternalProps = {}> = ExternalProps & UseTreeItem2LabelSlotOwnProps;
+export interface UseTreeItem2GroupTransitionSlotOwnProps {
+    unmountOnExit: boolean;
+    in: boolean;
+    component: 'ul';
+    role: 'group';
+    children: React.ReactNode;
+}
+export type UseTreeItem2GroupTransitionSlotProps<ExternalProps = {}> = ExternalProps & UseTreeItem2GroupTransitionSlotOwnProps;
+export interface UseTreeItem2Status {
+    expandable: boolean;
+    expanded: boolean;
+    focused: boolean;
+    selected: boolean;
+    disabled: boolean;
+}
+export interface UseTreeItem2ReturnValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
+    /**
+     * Resolver for the root slot's props.
+     * @param {ExternalProps} externalProps Additional props for the root slot
+     * @returns {UseTreeItem2RootSlotProps<ExternalProps>} Props that should be spread on the root slot
+     */
+    getRootProps: <ExternalProps extends Record<string, any> = {}>(externalProps?: ExternalProps) => UseTreeItem2RootSlotProps<ExternalProps>;
+    /**
+     * Resolver for the content slot's props.
+     * @param {ExternalProps} externalProps Additional props for the content slot
+     * @returns {UseTreeItem2ContentSlotProps<ExternalProps>} Props that should be spread on the content slot
+     */
+    getContentProps: <ExternalProps extends Record<string, any> = {}>(externalProps?: ExternalProps) => UseTreeItem2ContentSlotProps<ExternalProps>;
+    /**
+     * Resolver for the label slot's props.
+     * @param {ExternalProps} externalProps Additional props for the label slot
+     * @returns {UseTreeItem2LabelSlotProps<ExternalProps>} Props that should be spread on the label slot
+     */
+    getLabelProps: <ExternalProps extends Record<string, any> = {}>(externalProps?: ExternalProps) => UseTreeItem2LabelSlotProps<ExternalProps>;
+    /**
+     * Resolver for the iconContainer slot's props.
+     * @param {ExternalProps} externalProps Additional props for the iconContainer slot
+     * @returns {UseTreeItemIconContainerSlotProps<ExternalProps>} Props that should be spread on the iconContainer slot
+     */
+    getIconContainerProps: <ExternalProps extends Record<string, any> = {}>(externalProps?: ExternalProps) => UseTreeItemIconContainerSlotProps<ExternalProps>;
+    /**
+     * Resolver for the GroupTransition slot's props.
+     * @param {ExternalProps} externalProps Additional props for the GroupTransition slot
+     * @returns {UseTreeItem2GroupTransitionSlotProps<ExternalProps>} Props that should be spread on the GroupTransition slot
+     */
+    getGroupTransitionProps: <ExternalProps extends Record<string, any> = {}>(externalProps?: ExternalProps) => UseTreeItem2GroupTransitionSlotProps<ExternalProps>;
+    /**
+     * A ref to the component's root DOM element.
+     */
+    rootRef: React.RefCallback<HTMLLIElement> | null;
+    /**
+     * Current status of the item.
+     */
+    status: UseTreeItem2Status;
+    /**
+     * The object the allows Tree View manipulation.
+     */
+    publicAPI: TreeViewPublicAPI<TPlugins>;
+}

package/useTreeItem2/useTreeItem2.types.js

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