@mui/x-tree-view 8.0.0-alpha.9 → 8.0.0-beta.0

package/esm/internals/plugins/useTreeViewSelection/useTreeViewSelection.selectors.d.ts

@@ -0,0 +1,32 @@
+import { TreeViewRootSelector } from "../../utils/selectors.js";
+import { UseTreeViewSelectionSignature } from "./useTreeViewSelection.types.js";
+/**
+ * Check if an item is selected.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if the item is selected, `false` otherwise.
+ */
+export declare const selectorIsItemSelected: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    selectedItemsMap: Map<string, true>;
+  }, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    selectedItemsMap: Map<string, true>;
+  }, resultFuncArgs_1: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

package/esm/internals/plugins/useTreeViewSelection/useTreeViewSelection.selectors.js

@@ -0,0 +1,9 @@
+import { createSelector } from "../../utils/selectors.js";
+const selectorTreeViewSelectionState = state => state.selection;
+
+/**
+ * Check if an item is selected.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if the item is selected, `false` otherwise.
+ */
+export const selectorIsItemSelected = createSelector([selectorTreeViewSelectionState, (_, itemId) => itemId], (selectionState, itemId) => selectionState.selectedItemsMap.has(itemId));

package/esm/internals/plugins/useTreeViewSelection/useTreeViewSelection.types.d.ts

@@ -0,0 +1,144 @@
+import * as React from 'react';
+import type { DefaultizedProps } from '@mui/x-internals/types';
+import type { TreeViewPluginSignature } from '../../models';
+import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
+import { UseTreeViewExpansionSignature } from "../useTreeViewExpansion/index.js";
+import { TreeViewSelectionPropagation, TreeViewCancellableEventHandler } from "../../../models/index.js";
+export interface UseTreeViewSelectionPublicAPI {
+  /**
+   * Select or deselect an item.
+   * @param {object} parameters The parameters of the method.
+   * @param {string} parameters.itemId The id of the item to select or deselect.
+   * @param {React.SyntheticEvent} parameters.event The DOM event that triggered the change.
+   * @param {boolean} parameters.keepExistingSelection If `true`, the other already selected items will remain selected, otherwise, they will be deselected. This parameter is only relevant when `multiSelect` is `true`
+   * @param {boolean | undefined} parameters.shouldBeSelected If `true` the item will be selected. If `false` the item will be deselected. If not defined, the item's selection status will be toggled.
+   */
+  setItemSelection: (parameters: {
+    itemId: string;
+    event?: React.SyntheticEvent;
+    shouldBeSelected?: boolean;
+    keepExistingSelection?: boolean;
+  }) => void;
+}
+export interface UseTreeViewSelectionInstance extends UseTreeViewSelectionPublicAPI {
+  /**
+   * Select all the navigable items in the tree.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   */
+  selectAllNavigableItems: (event: React.SyntheticEvent) => void;
+  /**
+   * Expand the current selection range up to the given item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string} itemId The id of the item to expand the selection to.
+   */
+  expandSelectionRange: (event: React.SyntheticEvent, itemId: string) => void;
+  /**
+   * Expand the current selection range from the first navigable item to the given item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string} itemId The id of the item up to which the selection range should be expanded.
+   */
+  selectRangeFromStartToItem: (event: React.SyntheticEvent, itemId: string) => void;
+  /**
+   * Expand the current selection range from the given item to the last navigable item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string} itemId The id of the item from which the selection range should be expanded.
+   */
+  selectRangeFromItemToEnd: (event: React.SyntheticEvent, itemId: string) => void;
+  /**
+   * Update the selection when navigating with ArrowUp / ArrowDown keys.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string} currentItemId The id of the active item before the keyboard navigation.
+   * @param {string} nextItemId The id of the active item after the keyboard navigation.
+   */
+  selectItemFromArrowNavigation: (event: React.SyntheticEvent, currentItemId: string, nextItemId: string) => void;
+}
+type TreeViewSelectionValue<Multiple extends boolean | undefined> = Multiple extends true ? string[] : string | null;
+export interface UseTreeViewSelectionParameters<Multiple extends boolean | undefined> {
+  /**
+   * If `true` selection is disabled.
+   * @default false
+   */
+  disableSelection?: boolean;
+  /**
+   * Selected item ids. (Uncontrolled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   * @default []
+   */
+  defaultSelectedItems?: TreeViewSelectionValue<Multiple>;
+  /**
+   * Selected item ids. (Controlled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   */
+  selectedItems?: TreeViewSelectionValue<Multiple>;
+  /**
+   * If `true`, `ctrl` and `shift` will trigger multiselect.
+   * @default false
+   */
+  multiSelect?: Multiple;
+  /**
+   * If `true`, the Tree View renders a checkbox at the left of its label that allows selecting it.
+   * @default false
+   */
+  checkboxSelection?: boolean;
+  /**
+   * When `selectionPropagation.descendants` is set to `true`.
+   *
+   * - Selecting a parent selects all its descendants automatically.
+   * - Deselecting a parent deselects all its descendants automatically.
+   *
+   * When `selectionPropagation.parents` is set to `true`.
+   *
+   * - Selecting all the descendants of a parent selects the parent automatically.
+   * - Deselecting a descendant of a selected parent deselects the parent automatically.
+   *
+   * Only works when `multiSelect` is `true`.
+   * On the <SimpleTreeView />, only the expanded items are considered (since the collapsed item are not passed to the Tree View component at all)
+   *
+   * @default { parents: false, descendants: false }
+   */
+  selectionPropagation?: TreeViewSelectionPropagation;
+  /**
+   * Callback fired when Tree Items are selected/deselected.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemSelection()` method.
+   * @param {string[] | string} itemIds The ids of the selected items.
+   * When `multiSelect` is `true`, this is an array of strings; when false (default) a string.
+   */
+  onSelectedItemsChange?: (event: React.SyntheticEvent | null, itemIds: TreeViewSelectionValue<Multiple>) => void;
+  /**
+   * Callback fired when a Tree Item is selected or deselected.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemSelection()` method.
+   * @param {array} itemId The itemId of the modified item.
+   * @param {array} isSelected `true` if the item has just been selected, `false` if it has just been deselected.
+   */
+  onItemSelectionToggle?: (event: React.SyntheticEvent | null, itemId: string, isSelected: boolean) => void;
+}
+export type UseTreeViewSelectionDefaultizedParameters<Multiple extends boolean> = DefaultizedProps<UseTreeViewSelectionParameters<Multiple>, 'disableSelection' | 'defaultSelectedItems' | 'multiSelect' | 'checkboxSelection' | 'selectionPropagation'>;
+export interface UseTreeViewSelectionState {
+  selection: {
+    selectedItemsMap: Map<string, true>;
+  };
+}
+interface UseTreeViewSelectionContextValue {
+  selection: Pick<UseTreeViewSelectionDefaultizedParameters<boolean>, 'multiSelect' | 'checkboxSelection' | 'disableSelection' | 'selectionPropagation'>;
+}
+export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
+  params: UseTreeViewSelectionParameters<any>;
+  defaultizedParams: UseTreeViewSelectionDefaultizedParameters<any>;
+  instance: UseTreeViewSelectionInstance;
+  publicAPI: UseTreeViewSelectionPublicAPI;
+  contextValue: UseTreeViewSelectionContextValue;
+  modelNames: 'selectedItems';
+  state: UseTreeViewSelectionState;
+  dependencies: [UseTreeViewItemsSignature, UseTreeViewExpansionSignature, UseTreeViewItemsSignature];
+}>;
+export interface UseTreeItemCheckboxSlotPropsFromSelection {
+  visible?: boolean;
+  checked?: boolean;
+  disabled?: boolean;
+  tabIndex?: -1;
+  onChange?: TreeViewCancellableEventHandler<React.ChangeEvent<HTMLInputElement>>;
+}
+declare module '@mui/x-tree-view/useTreeItem' {
+  interface UseTreeItemCheckboxSlotOwnProps extends UseTreeItemCheckboxSlotPropsFromSelection {}
+}
+export {};

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

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

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

@@ -0,0 +1,38 @@
+import { TreeViewItemId, TreeViewSelectionPropagation } from "../../../models/index.js";
+import { TreeViewUsedStore } from "../../models/index.js";
+import { UseTreeViewSelectionSignature } from "./useTreeViewSelection.types.js";
+/**
+ * Transform the `selectedItems` model to be an array if it was a string or null.
+ * @param {string[] | string | null} model The raw model.
+ * @returns {string[]} The converted model.
+ */
+export declare const convertSelectedItemsToArray: (model: string[] | string | null) => string[];
+export declare const createSelectedItemsMap: (selectedItems: string | string[] | null) => Map<string, true>;
+export declare const getLookupFromArray: (array: string[]) => {
+  [itemId: string]: true;
+};
+export declare const getAddedAndRemovedItems: ({
+  store,
+  oldModel,
+  newModel
+}: {
+  store: TreeViewUsedStore<UseTreeViewSelectionSignature>;
+  oldModel: TreeViewItemId[];
+  newModel: TreeViewItemId[];
+}) => {
+  added: string[];
+  removed: string[];
+};
+export declare const propagateSelection: ({
+  store,
+  selectionPropagation,
+  newModel,
+  oldModel,
+  additionalItemsToPropagate
+}: {
+  store: TreeViewUsedStore<UseTreeViewSelectionSignature>;
+  selectionPropagation: TreeViewSelectionPropagation;
+  newModel: TreeViewItemId[];
+  oldModel: TreeViewItemId[];
+  additionalItemsToPropagate?: TreeViewItemId[];
+}) => string[];

package/{node → esm}/internals/plugins/useTreeViewSelection/useTreeViewSelection.utils.js

@@ -1,17 +1,12 @@
-"use strict";
+import { selectorIsItemSelected } from "./useTreeViewSelection.selectors.js";
+import { selectorItemOrderedChildrenIds, selectorItemParentId } from "../useTreeViewItems/useTreeViewItems.selectors.js";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.propagateSelection = exports.getLookupFromArray = exports.getAddedAndRemovedItems = exports.createSelectedItemsMap = exports.convertSelectedItemsToArray = void 0;
-var _useTreeViewSelection = require("./useTreeViewSelection.selectors");
-var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
 /**
  * Transform the `selectedItems` model to be an array if it was a string or null.
  * @param {string[] | string | null} model The raw model.
  * @returns {string[]} The converted model.
  */
-const convertSelectedItemsToArray = model => {
+export const convertSelectedItemsToArray = model => {
   if (Array.isArray(model)) {
     return model;
   }
@@ -20,36 +15,32 @@ const convertSelectedItemsToArray = model => {
   }
   return [];
 };
-exports.convertSelectedItemsToArray = convertSelectedItemsToArray;
-const createSelectedItemsMap = selectedItems => {
+export const createSelectedItemsMap = selectedItems => {
   const selectedItemsMap = new Map();
   convertSelectedItemsToArray(selectedItems).forEach(id => {
     selectedItemsMap.set(id, true);
   });
   return selectedItemsMap;
 };
-exports.createSelectedItemsMap = createSelectedItemsMap;
-const getLookupFromArray = array => {
+export const getLookupFromArray = array => {
   const lookup = {};
   array.forEach(itemId => {
     lookup[itemId] = true;
   });
   return lookup;
 };
-exports.getLookupFromArray = getLookupFromArray;
-const getAddedAndRemovedItems = ({
+export const getAddedAndRemovedItems = ({
   store,
   oldModel,
   newModel
 }) => {
   const newModelLookup = createSelectedItemsMap(newModel);
   return {
-    added: newModel.filter(itemId => !(0, _useTreeViewSelection.selectorIsItemSelected)(store.value, itemId)),
+    added: newModel.filter(itemId => !selectorIsItemSelected(store.value, itemId)),
     removed: oldModel.filter(itemId => !newModelLookup.has(itemId))
   };
 };
-exports.getAddedAndRemovedItems = getAddedAndRemovedItems;
-const propagateSelection = ({
+export const propagateSelection = ({
   store,
   selectionPropagation,
   newModel,
@@ -82,7 +73,7 @@ const propagateSelection = ({
           shouldRegenerateModel = true;
           newModelLookup[itemId] = true;
         }
-        (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId).forEach(selectDescendants);
+        selectorItemOrderedChildrenIds(store.value, itemId).forEach(selectDescendants);
       };
       selectDescendants(addedItemId);
     }
@@ -91,15 +82,15 @@ const propagateSelection = ({
         if (!newModelLookup[itemId]) {
           return false;
         }
-        const children = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId);
+        const children = selectorItemOrderedChildrenIds(store.value, itemId);
         return children.every(checkAllDescendantsSelected);
       };
       const selectParents = itemId => {
-        const parentId = (0, _useTreeViewItems.selectorItemParentId)(store.value, itemId);
+        const parentId = selectorItemParentId(store.value, itemId);
         if (parentId == null) {
           return;
         }
-        const siblings = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, parentId);
+        const siblings = selectorItemOrderedChildrenIds(store.value, parentId);
         if (siblings.every(checkAllDescendantsSelected)) {
           shouldRegenerateModel = true;
           newModelLookup[parentId] = true;
@@ -111,13 +102,13 @@ const propagateSelection = ({
   });
   changes.removed.forEach(removedItemId => {
     if (selectionPropagation.parents) {
-      let parentId = (0, _useTreeViewItems.selectorItemParentId)(store.value, removedItemId);
+      let parentId = selectorItemParentId(store.value, removedItemId);
       while (parentId != null) {
         if (newModelLookup[parentId]) {
           shouldRegenerateModel = true;
           delete newModelLookup[parentId];
         }
-        parentId = (0, _useTreeViewItems.selectorItemParentId)(store.value, parentId);
+        parentId = selectorItemParentId(store.value, parentId);
       }
     }
     if (selectionPropagation.descendants) {
@@ -126,11 +117,10 @@ const propagateSelection = ({
           shouldRegenerateModel = true;
           delete newModelLookup[itemId];
         }
-        (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId).forEach(deSelectDescendants);
+        selectorItemOrderedChildrenIds(store.value, itemId).forEach(deSelectDescendants);
       };
       deSelectDescendants(removedItemId);
     }
   });
   return shouldRegenerateModel ? Object.keys(newModelLookup) : newModel;
-};
-exports.propagateSelection = propagateSelection;
+};

package/esm/internals/useTreeView/extractPluginParamsFromProps.d.ts

@@ -0,0 +1,22 @@
+import { ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewAnyPluginSignature, TreeViewPluginSignature } from "../models/index.js";
+import { UseTreeViewBaseProps } from "./useTreeView.types.js";
+import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
+interface ExtractPluginParamsFromPropsParameters<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> {
+  plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>;
+  props: TProps;
+}
+interface ExtractPluginParamsFromPropsReturnValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> extends UseTreeViewBaseProps<TSignatures> {
+  pluginParams: MergeSignaturesProperty<TSignatures, 'defaultizedParams'>;
+  forwardedProps: Omit<TProps, keyof MergeSignaturesProperty<TSignatures, 'params'>>;
+}
+export declare const extractPluginParamsFromProps: <TSignatures extends readonly TreeViewPluginSignature<any>[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
+  props: {
+    slots,
+    slotProps,
+    apiRef,
+    experimentalFeatures: inExperimentalFeatures,
+    ...props
+  },
+  plugins
+}: ExtractPluginParamsFromPropsParameters<TSignatures, TProps>) => ExtractPluginParamsFromPropsReturnValue<TSignatures, TProps>;
+export {};

package/{node → esm}/internals/useTreeView/extractPluginParamsFromProps.js

@@ -1,13 +1,6 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.extractPluginParamsFromProps = void 0;
-var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 const _excluded = ["slots", "slotProps", "apiRef", "experimentalFeatures"];
-const extractPluginParamsFromProps = _ref => {
+export const extractPluginParamsFromProps = _ref => {
   let {
       props: {
         slots,
@@ -17,7 +10,7 @@ const extractPluginParamsFromProps = _ref => {
       },
       plugins
     } = _ref,
-    props = (0, _objectWithoutPropertiesLoose2.default)(_ref.props, _excluded);
+    props = _objectWithoutPropertiesLoose(_ref.props, _excluded);
   const paramsLookup = {};
   plugins.forEach(plugin => {
     Object.assign(paramsLookup, plugin.params);
@@ -50,5 +43,4 @@ const extractPluginParamsFromProps = _ref => {
     slotProps: slotProps ?? {},
     experimentalFeatures
   };
-};
-exports.extractPluginParamsFromProps = extractPluginParamsFromProps;
+};

package/esm/internals/useTreeView/index.d.ts

@@ -0,0 +1 @@
+export { useTreeView } from "./useTreeView.js";

package/esm/internals/useTreeView/index.js

@@ -0,0 +1 @@
+export { useTreeView } from "./useTreeView.js";

package/esm/internals/useTreeView/useTreeView.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { TreeViewAnyPluginSignature } from "../models/index.js";
+import { UseTreeViewBaseProps, UseTreeViewParameters, UseTreeViewReturnValue } from "./useTreeView.types.js";
+export declare function useTreeViewApiInitialization<T>(inputApiRef: React.RefObject<T | undefined> | undefined): T;
+export declare const useTreeView: <TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
+  plugins: inPlugins,
+  rootRef,
+  props
+}: UseTreeViewParameters<TSignatures, TProps>) => UseTreeViewReturnValue<TSignatures>;

package/{node → esm}/internals/useTreeView/useTreeView.js

@@ -1,21 +1,12 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTreeView = void 0;
-exports.useTreeViewApiInitialization = useTreeViewApiInitialization;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var React = _interopRequireWildcard(require("react"));
-var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
-var _useTreeViewModels = require("./useTreeViewModels");
-var _corePlugins = require("../corePlugins");
-var _extractPluginParamsFromProps = require("./extractPluginParamsFromProps");
-var _useTreeViewBuildContext = require("./useTreeViewBuildContext");
-var _TreeViewStore = require("../utils/TreeViewStore");
-function useTreeViewApiInitialization(inputApiRef) {
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import useForkRef from '@mui/utils/useForkRef';
+import { useTreeViewModels } from "./useTreeViewModels.js";
+import { TREE_VIEW_CORE_PLUGINS } from "../corePlugins/index.js";
+import { extractPluginParamsFromProps } from "./extractPluginParamsFromProps.js";
+import { useTreeViewBuildContext } from "./useTreeViewBuildContext.js";
+import { TreeViewStore } from "../utils/TreeViewStore.js";
+export function useTreeViewApiInitialization(inputApiRef) {
   const fallbackPublicApiRef = React.useRef({});
   if (inputApiRef) {
     if (inputApiRef.current == null) {
@@ -26,12 +17,12 @@ function useTreeViewApiInitialization(inputApiRef) {
   return fallbackPublicApiRef.current;
 }
 let globalId = 0;
-const useTreeView = ({
+export const useTreeView = ({
   plugins: inPlugins,
   rootRef,
   props
 }) => {
-  const plugins = React.useMemo(() => [..._corePlugins.TREE_VIEW_CORE_PLUGINS, ...inPlugins], [inPlugins]);
+  const plugins = React.useMemo(() => [...TREE_VIEW_CORE_PLUGINS, ...inPlugins], [inPlugins]);
   const {
     pluginParams,
     forwardedProps,
@@ -39,16 +30,16 @@ const useTreeView = ({
     experimentalFeatures,
     slots,
     slotProps
-  } = (0, _extractPluginParamsFromProps.extractPluginParamsFromProps)({
+  } = extractPluginParamsFromProps({
     plugins,
     props
   });
-  const models = (0, _useTreeViewModels.useTreeViewModels)(plugins, pluginParams);
+  const models = useTreeViewModels(plugins, pluginParams);
   const instanceRef = React.useRef({});
   const instance = instanceRef.current;
   const publicAPI = useTreeViewApiInitialization(apiRef);
   const innerRootRef = React.useRef(null);
-  const handleRootRef = (0, _useForkRef.default)(innerRootRef, rootRef);
+  const handleRootRef = useForkRef(innerRootRef, rootRef);
   const storeRef = React.useRef(null);
   if (storeRef.current == null) {
     globalId += 1;
@@ -62,9 +53,9 @@ const useTreeView = ({
         Object.assign(initialState, plugin.getInitialState(pluginParams));
       }
     });
-    storeRef.current = new _TreeViewStore.TreeViewStore(initialState);
+    storeRef.current = new TreeViewStore(initialState);
   }
-  const baseContextValue = (0, _useTreeViewBuildContext.useTreeViewBuildContext)({
+  const baseContextValue = useTreeViewBuildContext({
     plugins,
     instance,
     publicAPI,
@@ -100,7 +91,7 @@ const useTreeView = ({
   };
   plugins.forEach(runPlugin);
   const getRootProps = (otherHandlers = {}) => {
-    const rootProps = (0, _extends2.default)({
+    const rootProps = _extends({
       role: 'tree'
     }, forwardedProps, otherHandlers, {
       ref: handleRootRef
@@ -111,7 +102,7 @@ const useTreeView = ({
     return rootProps;
   };
   const contextValue = React.useMemo(() => {
-    const copiedBaseContextValue = (0, _extends2.default)({}, baseContextValue);
+    const copiedBaseContextValue = _extends({}, baseContextValue);
     return Object.assign(copiedBaseContextValue, ...pluginContextValues);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [baseContextValue, ...pluginContextValues]);
@@ -120,5 +111,4 @@ const useTreeView = ({
     rootRef: handleRootRef,
     contextValue
   };
-};
-exports.useTreeView = useTreeView;
+};

package/esm/internals/useTreeView/useTreeView.types.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { EventHandlers } from '@mui/utils/types';
+import type { TreeViewContextValue } from '../TreeViewProvider';
+import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewPublicAPI, TreeViewExperimentalFeatures } from "../models/index.js";
+export interface UseTreeViewParameters<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> {
+  plugins: ConvertSignaturesIntoPlugins<TSignatures>;
+  rootRef?: React.Ref<HTMLUListElement> | undefined;
+  props: TProps;
+}
+export interface UseTreeViewBaseProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
+  apiRef: React.RefObject<TreeViewPublicAPI<TSignatures> | undefined> | undefined;
+  slots: MergeSignaturesProperty<TSignatures, 'slots'>;
+  slotProps: MergeSignaturesProperty<TSignatures, 'slotProps'>;
+  experimentalFeatures: TreeViewExperimentalFeatures<TSignatures>;
+}
+export interface UseTreeViewRootSlotProps extends Pick<React.HTMLAttributes<HTMLUListElement>, 'onFocus' | 'onBlur' | 'onKeyDown' | 'id' | 'aria-multiselectable' | 'role' | 'tabIndex'> {
+  ref: React.Ref<HTMLUListElement>;
+}
+export interface UseTreeViewReturnValue<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
+  getRootProps: <TOther extends EventHandlers = {}>(otherHandlers?: TOther) => UseTreeViewRootSlotProps;
+  rootRef: React.RefCallback<HTMLUListElement> | null;
+  contextValue: TreeViewContextValue<TSignatures>;
+}

package/esm/internals/useTreeView/useTreeView.types.js

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

package/esm/internals/useTreeView/useTreeViewBuildContext.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { TreeViewContextValue } from "../TreeViewProvider/index.js";
+import { ConvertSignaturesIntoPlugins, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewPublicAPI } from "../models/index.js";
+import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
+import { TreeViewStore } from "../utils/TreeViewStore.js";
+export declare const useTreeViewBuildContext: <TSignatures extends readonly TreeViewAnyPluginSignature[]>({
+  plugins,
+  instance,
+  publicAPI,
+  store,
+  rootRef
+}: {
+  plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>;
+  instance: TreeViewInstance<TSignatures>;
+  publicAPI: TreeViewPublicAPI<TSignatures>;
+  store: TreeViewStore<TSignatures>;
+  rootRef: React.RefObject<HTMLUListElement | null>;
+}) => TreeViewContextValue<TSignatures>;

package/{node → esm}/internals/useTreeView/useTreeViewBuildContext.js

@@ -1,12 +1,5 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTreeViewBuildContext = void 0;
-var React = _interopRequireWildcard(require("react"));
-const useTreeViewBuildContext = ({
+import * as React from 'react';
+export const useTreeViewBuildContext = ({
   plugins,
   instance,
   publicAPI,
@@ -105,5 +98,4 @@ const useTreeViewBuildContext = ({
       rootRef
     };
   }, [runItemPlugins, wrapItem, wrapRoot, instance, publicAPI, store, rootRef]);
-};
-exports.useTreeViewBuildContext = useTreeViewBuildContext;
+};

package/esm/internals/useTreeView/useTreeViewModels.d.ts

@@ -0,0 +1,7 @@
+import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty } from "../models/index.js";
+import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
+/**
+ * Implements the same behavior as `useControlled` but for several models.
+ * The controlled models are never stored in the state, and the state is only updated if the model is not controlled.
+ */
+export declare const useTreeViewModels: <TSignatures extends readonly TreeViewAnyPluginSignature[]>(plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>, props: MergeSignaturesProperty<TSignatures, "defaultizedParams">) => MergeSignaturesProperty<TSignatures, "models">;

package/{node → esm}/internals/useTreeView/useTreeViewModels.js

@@ -1,18 +1,10 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTreeViewModels = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var React = _interopRequireWildcard(require("react"));
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
 /**
  * Implements the same behavior as `useControlled` but for several models.
  * The controlled models are never stored in the state, and the state is only updated if the model is not controlled.
  */
-const useTreeViewModels = (plugins, props) => {
+export const useTreeViewModels = (plugins, props) => {
   const modelsRef = React.useRef({});
   const [modelsState, setModelsState] = React.useState(() => {
     const initialState = {};
@@ -35,7 +27,7 @@ const useTreeViewModels = (plugins, props) => {
       value,
       setControlledValue: newValue => {
         if (!model.isControlled) {
-          setModelsState(prevState => (0, _extends2.default)({}, prevState, {
+          setModelsState(prevState => _extends({}, prevState, {
             [modelName]: newValue
           }));
         }
@@ -67,5 +59,4 @@ const useTreeViewModels = (plugins, props) => {
   /* eslint-enable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
 
   return models;
-};
-exports.useTreeViewModels = useTreeViewModels;
+};