@mui/x-tree-view 8.10.2 → 8.11.1

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

@@ -1,81 +1,56 @@
-import { createSelector } from "../../utils/selectors.js";
-import { selectorIsItemDisabled } from "../useTreeViewItems/useTreeViewItems.selectors.js";
-const selectorTreeViewSelectionState = state => state.selection;
-
-/**
- * Get the selected items.
- * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
- * @returns {TreeViewSelectionValue<boolean>} The selected items.
- */
-export const selectorSelectionModel = createSelector([selectorTreeViewSelectionState], selectionState => selectionState.selectedItems);
-
-/**
- * Get the selected items as an array.
- * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
- * @returns {TreeViewItemId[]} The selected items as an array.
- */
-export const selectorSelectionModelArray = createSelector([selectorSelectionModel], selectedItems => {
-  if (Array.isArray(selectedItems)) {
-    return selectedItems;
+import { createSelector, createSelectorMemoized } from '@mui/x-internals/store';
+import { itemsSelectors } from "../useTreeViewItems/useTreeViewItems.selectors.js";
+const selectedItemsSelector = createSelectorMemoized(state => state.selection.selectedItems, selectedItemsRaw => {
+  if (Array.isArray(selectedItemsRaw)) {
+    return selectedItemsRaw;
   }
-  if (selectedItems != null) {
-    return [selectedItems];
+  if (selectedItemsRaw != null) {
+    return [selectedItemsRaw];
   }
   return [];
 });
-
-/**
- * Get the selected items as a map.
- * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
- * @returns {Map<TreeViewItemId, true>} The selected items as a Map.
- */
-const selectorSelectionModelMap = createSelector([selectorSelectionModelArray], selectedItems => {
+const selectedItemsMapSelector = createSelectorMemoized(selectedItemsSelector, selectedItems => {
   const selectedItemsMap = new Map();
   selectedItems.forEach(id => {
     selectedItemsMap.set(id, true);
   });
   return selectedItemsMap;
 });
-
-/**
- * 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([selectorSelectionModelMap, (_, itemId) => itemId], (selectedItemsMap, itemId) => selectedItemsMap.has(itemId));
-
-/**
- * Check if multi selection is enabled.
- * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
- * @returns {boolean} `true` if multi selection is enabled, `false` otherwise.
- */
-export const selectorIsMultiSelectEnabled = createSelector([selectorTreeViewSelectionState], selectionState => selectionState.isEnabled && selectionState.isMultiSelectEnabled);
-
-/**
- * Check if selection is enabled.
- * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
- * @returns {boolean} `true` if selection is enabled, `false` otherwise.
- */
-export const selectorIsSelectionEnabled = createSelector([selectorTreeViewSelectionState], selectionState => selectionState.isEnabled);
-
-/**
- * Check if checkbox selection is enabled.
- * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
- * @returns {boolean} `true` if checkbox selection is enabled, `false` otherwise.
- */
-export const selectorIsCheckboxSelectionEnabled = createSelector([selectorTreeViewSelectionState], selectionState => selectionState.isCheckboxSelectionEnabled);
-
-/**
- * Check if selection is enabled for an item (if selection is enabled and if the item is not disabled).
- * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
- * @param {string} itemId The id of the item to check.
- * @returns {boolean} `true` if selection is enabled for the item, `false` otherwise.
- */
-export const selectorIsItemSelectionEnabled = createSelector([selectorIsItemDisabled, selectorIsSelectionEnabled], (isItemDisabled, isSelectionEnabled) => isSelectionEnabled && !isItemDisabled);
-
-/**
- * Get the selection propagation rules.
- * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
- * @returns {TreeViewSelectionPropagation} The selection propagation rules.
- */
-export const selectorSelectionPropagationRules = createSelector([selectorTreeViewSelectionState], selectionState => selectionState.selectionPropagation);
+export const selectionSelectors = {
+  /**
+   * Gets the selected items as provided to the component.
+   */
+  selectedItemsRaw: createSelector(state => state.selection.selectedItems),
+  /**
+   * Gets the selected items as an array.
+   */
+  selectedItems: selectedItemsSelector,
+  /**
+   * Gets the selected items as a Map.
+   */
+  selectedItemsMap: selectedItemsMapSelector,
+  /**
+   * Checks whether selection is enabled.
+   */
+  enabled: createSelector(state => state.selection.isEnabled),
+  /**
+   * Checks whether multi selection is enabled.
+   */
+  isMultiSelectEnabled: createSelector(state => state.selection.isMultiSelectEnabled),
+  /**
+   * Checks whether checkbox selection is enabled.
+   */
+  isCheckboxSelectionEnabled: createSelector(state => state.selection.isCheckboxSelectionEnabled),
+  /**
+   * Gets the selection propagation rules.
+   */
+  propagationRules: createSelector(state => state.selection.selectionPropagation),
+  /**
+   * Checks whether an item is selected.
+   */
+  isItemSelected: createSelector(selectedItemsMapSelector, (selectedItemsMap, itemId) => selectedItemsMap.has(itemId)),
+  /**
+   * Checks whether an item can be selected (if selection is enabled and if the item is not disabled).
+   */
+  canItemBeSelected: createSelector(itemsSelectors.isItemDisabled, state => state.selection.isEnabled, (isItemDisabled, isSelectionEnabled, _itemId) => isSelectionEnabled && !isItemDisabled)
+};

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

@@ -133,6 +133,7 @@ export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
 export interface UseTreeItemCheckboxSlotPropsFromSelection {
   visible?: boolean;
   checked?: boolean;
+  indeterminate?: boolean;
   disabled?: boolean;
   tabIndex?: -1;
   onChange?: TreeViewCancellableEventHandler<React.ChangeEvent<HTMLInputElement>>;

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

@@ -1,5 +1,5 @@
-import { selectorIsItemSelected } from "./useTreeViewSelection.selectors.js";
-import { selectorItemOrderedChildrenIds, selectorItemParentId } from "../useTreeViewItems/useTreeViewItems.selectors.js";
+import { selectionSelectors } from "./useTreeViewSelection.selectors.js";
+import { itemsSelectors } from "../useTreeViewItems/useTreeViewItems.selectors.js";
 export const getLookupFromArray = array => {
   const lookup = {};
   array.forEach(itemId => {
@@ -17,7 +17,7 @@ export const getAddedAndRemovedItems = ({
     newModelMap.set(id, true);
   });
   return {
-    added: newModel.filter(itemId => !selectorIsItemSelected(store.value, itemId)),
+    added: newModel.filter(itemId => !selectionSelectors.isItemSelected(store.state, itemId)),
     removed: oldModel.filter(itemId => !newModelMap.has(itemId))
   };
 };
@@ -54,7 +54,7 @@ export const propagateSelection = ({
           shouldRegenerateModel = true;
           newModelLookup[itemId] = true;
         }
-        selectorItemOrderedChildrenIds(store.value, itemId).forEach(selectDescendants);
+        itemsSelectors.itemOrderedChildrenIds(store.state, itemId).forEach(selectDescendants);
       };
       selectDescendants(addedItemId);
     }
@@ -63,15 +63,15 @@ export const propagateSelection = ({
         if (!newModelLookup[itemId]) {
           return false;
         }
-        const children = selectorItemOrderedChildrenIds(store.value, itemId);
+        const children = itemsSelectors.itemOrderedChildrenIds(store.state, itemId);
         return children.every(checkAllDescendantsSelected);
       };
       const selectParents = itemId => {
-        const parentId = selectorItemParentId(store.value, itemId);
+        const parentId = itemsSelectors.itemParentId(store.state, itemId);
         if (parentId == null) {
           return;
         }
-        const siblings = selectorItemOrderedChildrenIds(store.value, parentId);
+        const siblings = itemsSelectors.itemOrderedChildrenIds(store.state, parentId);
         if (siblings.every(checkAllDescendantsSelected)) {
           shouldRegenerateModel = true;
           newModelLookup[parentId] = true;
@@ -83,13 +83,13 @@ export const propagateSelection = ({
   });
   changes.removed.forEach(removedItemId => {
     if (selectionPropagation.parents) {
-      let parentId = selectorItemParentId(store.value, removedItemId);
+      let parentId = itemsSelectors.itemParentId(store.state, removedItemId);
       while (parentId != null) {
         if (newModelLookup[parentId]) {
           shouldRegenerateModel = true;
           delete newModelLookup[parentId];
         }
-        parentId = selectorItemParentId(store.value, parentId);
+        parentId = itemsSelectors.itemParentId(store.state, parentId);
       }
     }
     if (selectionPropagation.descendants) {
@@ -98,7 +98,7 @@ export const propagateSelection = ({
           shouldRegenerateModel = true;
           delete newModelLookup[itemId];
         }
-        selectorItemOrderedChildrenIds(store.value, itemId).forEach(deSelectDescendants);
+        itemsSelectors.itemOrderedChildrenIds(store.state, itemId).forEach(deSelectDescendants);
       };
       deSelectDescendants(removedItemId);
     }

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

@@ -1,7 +1,7 @@
 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): React.RefObject<T>;
+export declare function useTreeViewApiInitialization<T>(inputApiRef: React.RefObject<Partial<T> | undefined> | undefined): React.RefObject<T>;
 /**
  * This is the main hook that sets the plugin system up for the tree-view.
  *

package/esm/internals/useTreeView/useTreeView.js

@@ -1,10 +1,11 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
+import { useRefWithInit } from '@base-ui-components/utils/useRefWithInit';
+import { Store } from '@mui/x-internals/store';
 import useForkRef from '@mui/utils/useForkRef';
 import { TREE_VIEW_CORE_PLUGINS } from "../corePlugins/index.js";
 import { useExtractPluginParamsFromProps } from "./useExtractPluginParamsFromProps.js";
 import { useTreeViewBuildContext } from "./useTreeViewBuildContext.js";
-import { TreeViewStore } from "../utils/TreeViewStore.js";
 function initializeInputApiRef(inputApiRef) {
   if (inputApiRef.current == null) {
     inputApiRef.current = {};
@@ -18,7 +19,6 @@ export function useTreeViewApiInitialization(inputApiRef) {
   }
   return fallbackPublicApiRef;
 }
-let globalId = 0;
 
 /**
  * This is the main hook that sets the plugin system up for the tree-view.
@@ -43,31 +43,24 @@ export const useTreeView = ({
     plugins,
     props
   });
-  const instanceRef = React.useRef({});
-  const instance = instanceRef.current;
+  const instance = useRefWithInit(() => ({})).current;
   const publicAPI = useTreeViewApiInitialization(apiRef);
   const innerRootRef = React.useRef(null);
   const handleRootRef = useForkRef(innerRootRef, rootRef);
-  const storeRef = React.useRef(null);
-  if (storeRef.current == null) {
-    globalId += 1;
-    const initialState = {
-      cacheKey: {
-        id: globalId
-      }
-    };
-    plugins.forEach(plugin => {
+  const store = useRefWithInit(() => {
+    const initialState = {};
+    for (const plugin of plugins) {
       if (plugin.getInitialState) {
         Object.assign(initialState, plugin.getInitialState(pluginParams));
       }
-    });
-    storeRef.current = new TreeViewStore(initialState);
-  }
+    }
+    return new Store(initialState);
+  }).current;
   const contextValue = useTreeViewBuildContext({
     plugins,
     instance,
     publicAPI: publicAPI.current,
-    store: storeRef.current,
+    store,
     rootRef: innerRootRef
   });
   const rootPropsGetters = [];
@@ -77,7 +70,7 @@ export const useTreeView = ({
       params: pluginParams,
       rootRef: innerRootRef,
       plugins,
-      store: storeRef.current
+      store
     });
     if (pluginResponse.getRootProps) {
       rootPropsGetters.push(pluginResponse.getRootProps);

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

@@ -8,7 +8,7 @@ export interface UseTreeViewParameters<TSignatures extends readonly TreeViewAnyP
   props: TProps;
 }
 export interface UseTreeViewBaseProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
-  apiRef: React.RefObject<TreeViewPublicAPI<TSignatures> | undefined> | undefined;
+  apiRef: React.RefObject<Partial<TreeViewPublicAPI<TSignatures>> | undefined> | undefined;
 }
 export interface UseTreeViewRootSlotProps extends Pick<React.HTMLAttributes<HTMLUListElement>, 'onFocus' | 'onBlur' | 'onKeyDown' | 'id' | 'aria-multiselectable' | 'role' | 'tabIndex'> {
   ref: React.Ref<HTMLUListElement>;

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

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

package/esm/internals/utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking.js

@@ -10,7 +10,5 @@ export class FinalizationRegistryBasedCleanupTracking {
   unregister(unregisterToken) {
     this.registry.unregister(unregisterToken);
   }
-
-  // eslint-disable-next-line class-methods-use-this
   reset() {}
 }

package/esm/internals/utils/tree.js

@@ -1,9 +1,9 @@
-import { selectorIsItemExpandable, selectorIsItemExpanded } from "../plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
-import { selectorCanItemBeFocused, selectorIsItemDisabled, selectorItemIndex, selectorItemMeta, selectorItemOrderedChildrenIds, selectorItemParentId } from "../plugins/useTreeViewItems/useTreeViewItems.selectors.js";
+import { expansionSelectors } from "../plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
+import { itemsSelectors } from "../plugins/useTreeViewItems/useTreeViewItems.selectors.js";
 const getLastNavigableItemInArray = (state, items) => {
   // Equivalent to Array.prototype.findLastIndex
   let itemIndex = items.length - 1;
-  while (itemIndex >= 0 && !selectorCanItemBeFocused(state, items[itemIndex])) {
+  while (itemIndex >= 0 && !itemsSelectors.canItemBeFocused(state, items[itemIndex])) {
     itemIndex -= 1;
   }
   if (itemIndex === -1) {
@@ -12,12 +12,12 @@ const getLastNavigableItemInArray = (state, items) => {
   return items[itemIndex];
 };
 export const getPreviousNavigableItem = (state, itemId) => {
-  const itemMeta = selectorItemMeta(state, itemId);
+  const itemMeta = itemsSelectors.itemMeta(state, itemId);
   if (!itemMeta) {
     return null;
   }
-  const siblings = selectorItemOrderedChildrenIds(state, itemMeta.parentId);
-  const itemIndex = selectorItemIndex(state, itemId);
+  const siblings = itemsSelectors.itemOrderedChildrenIds(state, itemMeta.parentId);
+  const itemIndex = itemsSelectors.itemIndex(state, itemId);
 
   // TODO: What should we do if the parent is not navigable?
   if (itemIndex === 0) {
@@ -26,7 +26,7 @@ export const getPreviousNavigableItem = (state, itemId) => {
 
   // Finds the previous navigable sibling.
   let previousNavigableSiblingIndex = itemIndex - 1;
-  while (!selectorCanItemBeFocused(state, siblings[previousNavigableSiblingIndex]) && previousNavigableSiblingIndex >= 0) {
+  while (!itemsSelectors.canItemBeFocused(state, siblings[previousNavigableSiblingIndex]) && previousNavigableSiblingIndex >= 0) {
     previousNavigableSiblingIndex -= 1;
   }
   if (previousNavigableSiblingIndex === -1) {
@@ -41,45 +41,45 @@ export const getPreviousNavigableItem = (state, itemId) => {
 
   // Finds the last navigable ancestor of the previous navigable sibling.
   let currentItemId = siblings[previousNavigableSiblingIndex];
-  let lastNavigableChild = getLastNavigableItemInArray(state, selectorItemOrderedChildrenIds(state, currentItemId));
-  while (selectorIsItemExpanded(state, currentItemId) && lastNavigableChild != null) {
+  let lastNavigableChild = getLastNavigableItemInArray(state, itemsSelectors.itemOrderedChildrenIds(state, currentItemId));
+  while (expansionSelectors.isItemExpanded(state, currentItemId) && lastNavigableChild != null) {
     currentItemId = lastNavigableChild;
-    lastNavigableChild = getLastNavigableItemInArray(state, selectorItemOrderedChildrenIds(state, currentItemId));
+    lastNavigableChild = getLastNavigableItemInArray(state, itemsSelectors.itemOrderedChildrenIds(state, currentItemId));
   }
   return currentItemId;
 };
 export const getNextNavigableItem = (state, itemId) => {
   // If the item is expanded and has some navigable children, return the first of them.
-  if (selectorIsItemExpanded(state, itemId)) {
-    const firstNavigableChild = selectorItemOrderedChildrenIds(state, itemId).find(childId => selectorCanItemBeFocused(state, childId));
+  if (expansionSelectors.isItemExpanded(state, itemId)) {
+    const firstNavigableChild = itemsSelectors.itemOrderedChildrenIds(state, itemId).find(childId => itemsSelectors.canItemBeFocused(state, childId));
     if (firstNavigableChild != null) {
       return firstNavigableChild;
     }
   }
-  let itemMeta = selectorItemMeta(state, itemId);
+  let itemMeta = itemsSelectors.itemMeta(state, itemId);
   while (itemMeta != null) {
     // Try to find the first navigable sibling after the current item.
-    const siblings = selectorItemOrderedChildrenIds(state, itemMeta.parentId);
-    const currentItemIndex = selectorItemIndex(state, itemMeta.id);
+    const siblings = itemsSelectors.itemOrderedChildrenIds(state, itemMeta.parentId);
+    const currentItemIndex = itemsSelectors.itemIndex(state, itemMeta.id);
     if (currentItemIndex < siblings.length - 1) {
       let nextItemIndex = currentItemIndex + 1;
-      while (!selectorCanItemBeFocused(state, siblings[nextItemIndex]) && nextItemIndex < siblings.length - 1) {
+      while (!itemsSelectors.canItemBeFocused(state, siblings[nextItemIndex]) && nextItemIndex < siblings.length - 1) {
         nextItemIndex += 1;
       }
-      if (selectorCanItemBeFocused(state, siblings[nextItemIndex])) {
+      if (itemsSelectors.canItemBeFocused(state, siblings[nextItemIndex])) {
         return siblings[nextItemIndex];
       }
     }
 
     // If the sibling does not exist, go up a level to the parent and try again.
-    itemMeta = selectorItemMeta(state, itemMeta.parentId);
+    itemMeta = itemsSelectors.itemMeta(state, itemMeta.parentId);
   }
   return null;
 };
 export const getLastNavigableItem = state => {
   let itemId = null;
-  while (itemId == null || selectorIsItemExpanded(state, itemId)) {
-    const children = selectorItemOrderedChildrenIds(state, itemId);
+  while (itemId == null || expansionSelectors.isItemExpanded(state, itemId)) {
+    const children = itemsSelectors.itemOrderedChildrenIds(state, itemId);
     const lastNavigableChild = getLastNavigableItemInArray(state, children);
 
     // The item has no navigable children.
@@ -90,7 +90,7 @@ export const getLastNavigableItem = state => {
   }
   return itemId;
 };
-export const getFirstNavigableItem = state => selectorItemOrderedChildrenIds(state, null).find(itemId => selectorCanItemBeFocused(state, itemId));
+export const getFirstNavigableItem = state => itemsSelectors.itemOrderedChildrenIds(state, null).find(itemId => itemsSelectors.canItemBeFocused(state, itemId));
 
 /**
  * This is used to determine the start and end of a selection range so
@@ -110,8 +110,8 @@ export const findOrderInTremauxTree = (state, itemAId, itemBId) => {
   if (itemAId === itemBId) {
     return [itemAId, itemBId];
   }
-  const itemMetaA = selectorItemMeta(state, itemAId);
-  const itemMetaB = selectorItemMeta(state, itemBId);
+  const itemMetaA = itemsSelectors.itemMeta(state, itemAId);
+  const itemMetaB = itemsSelectors.itemMeta(state, itemBId);
   if (!itemMetaA || !itemMetaB) {
     return [itemAId, itemBId];
   }
@@ -132,7 +132,7 @@ export const findOrderInTremauxTree = (state, itemAId, itemBId) => {
       aAncestorIsCommon = bFamily.indexOf(aAncestor) !== -1;
       continueA = aAncestor !== null;
       if (!aAncestorIsCommon && continueA) {
-        aAncestor = selectorItemParentId(state, aAncestor);
+        aAncestor = itemsSelectors.itemParentId(state, aAncestor);
       }
     }
     if (continueB && !aAncestorIsCommon) {
@@ -140,12 +140,12 @@ export const findOrderInTremauxTree = (state, itemAId, itemBId) => {
       bAncestorIsCommon = aFamily.indexOf(bAncestor) !== -1;
       continueB = bAncestor !== null;
       if (!bAncestorIsCommon && continueB) {
-        bAncestor = selectorItemParentId(state, bAncestor);
+        bAncestor = itemsSelectors.itemParentId(state, bAncestor);
       }
     }
   }
   const commonAncestor = aAncestorIsCommon ? aAncestor : bAncestor;
-  const ancestorFamily = selectorItemOrderedChildrenIds(state, commonAncestor);
+  const ancestorFamily = itemsSelectors.itemOrderedChildrenIds(state, commonAncestor);
   const aSide = aFamily[aFamily.indexOf(commonAncestor) - 1];
   const bSide = bFamily[bFamily.indexOf(commonAncestor) - 1];
   return ancestorFamily.indexOf(aSide) < ancestorFamily.indexOf(bSide) ? [itemAId, itemBId] : [itemBId, itemAId];
@@ -153,20 +153,20 @@ export const findOrderInTremauxTree = (state, itemAId, itemBId) => {
 export const getNonDisabledItemsInRange = (state, itemAId, itemBId) => {
   const getNextItem = itemId => {
     // If the item is expanded and has some children, return the first of them.
-    if (selectorIsItemExpandable(state, itemId) && selectorIsItemExpanded(state, itemId)) {
-      return selectorItemOrderedChildrenIds(state, itemId)[0];
+    if (expansionSelectors.isItemExpandable(state, itemId) && expansionSelectors.isItemExpanded(state, itemId)) {
+      return itemsSelectors.itemOrderedChildrenIds(state, itemId)[0];
     }
-    let itemMeta = selectorItemMeta(state, itemId);
+    let itemMeta = itemsSelectors.itemMeta(state, itemId);
     while (itemMeta != null) {
       // Try to find the first navigable sibling after the current item.
-      const siblings = selectorItemOrderedChildrenIds(state, itemMeta.parentId);
-      const currentItemIndex = selectorItemIndex(state, itemMeta.id);
+      const siblings = itemsSelectors.itemOrderedChildrenIds(state, itemMeta.parentId);
+      const currentItemIndex = itemsSelectors.itemIndex(state, itemMeta.id);
       if (currentItemIndex < siblings.length - 1) {
         return siblings[currentItemIndex + 1];
       }
 
       // If the item is the last of its siblings, go up a level to the parent and try again.
-      itemMeta = itemMeta.parentId ? selectorItemMeta(state, itemMeta.parentId) : null;
+      itemMeta = itemMeta.parentId ? itemsSelectors.itemMeta(state, itemMeta.parentId) : null;
     }
     throw new Error('Invalid range');
   };
@@ -175,7 +175,7 @@ export const getNonDisabledItemsInRange = (state, itemAId, itemBId) => {
   let current = first;
   while (current !== last) {
     current = getNextItem(current);
-    if (!selectorIsItemDisabled(state, current)) {
+    if (!itemsSelectors.isItemDisabled(state, current)) {
       items.push(current);
     }
   }

package/esm/useTreeItem/useTreeItem.js

@@ -2,19 +2,19 @@
 
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
+import { useStore } from '@mui/x-internals/store';
 import extractEventHandlers from '@mui/utils/extractEventHandlers';
 import useForkRef from '@mui/utils/useForkRef';
 import { useTreeViewContext } from "../internals/TreeViewProvider/index.js";
 import { useTreeItemUtils } from "../hooks/useTreeItemUtils/index.js";
 import { TreeViewItemDepthContext } from "../internals/TreeViewItemDepthContext/index.js";
 import { isTargetInDescendants } from "../internals/utils/tree.js";
-import { useSelector } from "../internals/hooks/useSelector.js";
-import { selectorIsItemTheDefaultFocusableItem } from "../internals/plugins/useTreeViewFocus/useTreeViewFocus.selectors.js";
 import { generateTreeItemIdAttribute } from "../internals/corePlugins/useTreeViewId/useTreeViewId.utils.js";
-import { selectorCanItemBeFocused } from "../internals/plugins/useTreeViewItems/useTreeViewItems.selectors.js";
-import { selectorTreeViewId } from "../internals/corePlugins/useTreeViewId/useTreeViewId.selectors.js";
-import { selectorItemExpansionTrigger } from "../internals/plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
-import { selectorIsCheckboxSelectionEnabled, selectorIsItemSelectionEnabled } from "../internals/plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";
+import { focusSelectors } from "../internals/plugins/useTreeViewFocus/index.js";
+import { itemsSelectors } from "../internals/plugins/useTreeViewItems/index.js";
+import { idSelectors } from "../internals/corePlugins/useTreeViewId/index.js";
+import { expansionSelectors } from "../internals/plugins/useTreeViewExpansion/index.js";
+import { selectionSelectors } from "../internals/plugins/useTreeViewSelection/index.js";
 export const useTreeItem = parameters => {
   const {
     runItemPlugins,
@@ -23,7 +23,7 @@ export const useTreeItem = parameters => {
     store
   } = useTreeViewContext();
   const depthContext = React.useContext(TreeViewItemDepthContext);
-  const depth = useSelector(store, (...params) => {
+  const depth = useStore(store, (...params) => {
     if (typeof depthContext === 'function') {
       return depthContext(...params);
     }
@@ -53,15 +53,15 @@ export const useTreeItem = parameters => {
   const handleRootRef = useForkRef(rootRef, pluginRootRef, rootRefObject);
   const handleContentRef = useForkRef(contentRef, contentRefObject);
   const checkboxRef = React.useRef(null);
-  const treeId = useSelector(store, selectorTreeViewId);
-  const isSelectionEnabledForItem = useSelector(store, selectorIsItemSelectionEnabled, itemId);
-  const isCheckboxSelectionEnabled = useSelector(store, selectorIsCheckboxSelectionEnabled);
+  const treeId = useStore(store, idSelectors.treeId);
+  const isSelectionEnabledForItem = useStore(store, selectionSelectors.canItemBeSelected, itemId);
+  const isCheckboxSelectionEnabled = useStore(store, selectionSelectors.isCheckboxSelectionEnabled);
   const idAttribute = generateTreeItemIdAttribute({
     itemId,
     treeId,
     id
   });
-  const shouldBeAccessibleWithTab = useSelector(store, selectorIsItemTheDefaultFocusableItem, itemId);
+  const shouldBeAccessibleWithTab = useStore(store, focusSelectors.isItemTheDefaultFocusableItem, itemId);
   const sharedPropsEnhancerParams = {
     rootRefObject,
     contentRefObject,
@@ -72,7 +72,7 @@ export const useTreeItem = parameters => {
     if (event.defaultMuiPrevented) {
       return;
     }
-    if (!status.focused && selectorCanItemBeFocused(store.value, itemId) && event.currentTarget === event.target) {
+    if (!status.focused && itemsSelectors.canItemBeFocused(store.state, itemId) && event.currentTarget === event.target) {
       instance.focusItem(event, itemId);
     }
   };
@@ -114,7 +114,7 @@ export const useTreeItem = parameters => {
     if (event.defaultMuiPrevented || checkboxRef.current?.contains(event.target)) {
       return;
     }
-    if (selectorItemExpansionTrigger(store.value) === 'content') {
+    if (expansionSelectors.triggerSlot(store.state) === 'content') {
       interactions.handleExpansion(event);
     }
     if (!isCheckboxSelectionEnabled) {
@@ -137,7 +137,7 @@ export const useTreeItem = parameters => {
     if (event.defaultMuiPrevented) {
       return;
     }
-    if (selectorItemExpansionTrigger(store.value) === 'iconContainer') {
+    if (expansionSelectors.triggerSlot(store.state) === 'iconContainer') {
       interactions.handleExpansion(event);
     }
   };

package/esm/useTreeItem/useTreeItem.types.d.ts

@@ -7,6 +7,7 @@ import { UseTreeViewFocusSignature } from "../internals/plugins/useTreeViewFocus
 import { UseTreeViewKeyboardNavigationSignature } from "../internals/plugins/useTreeViewKeyboardNavigation/index.js";
 import { UseTreeViewLabelSignature } from "../internals/plugins/useTreeViewLabel/index.js";
 import { UseTreeViewExpansionSignature } from "../internals/plugins/useTreeViewExpansion/index.js";
+import { UseTreeViewLazyLoadingSignature } from "../internals/plugins/useTreeViewLazyLoading/index.js";
 export interface UseTreeItemParameters {
   /**
    * The id attribute of the item. If not provided, it will be generated.
@@ -199,4 +200,4 @@ export type UseTreeItemMinimalPlugins = readonly [UseTreeViewSelectionSignature,
 /**
  * Plugins that `UseTreeItem` can use if they are present, but are not required.
  */
-export type UseTreeItemOptionalPlugins = readonly [];
+export type UseTreeItemOptionalPlugins = readonly [UseTreeViewLazyLoadingSignature];

package/hooks/useTreeItemModel.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useTreeItemModel = void 0;
+var _store = require("@mui/x-internals/store");
 var _TreeViewProvider = require("../internals/TreeViewProvider");
-var _useSelector = require("../internals/hooks/useSelector");
-var _useTreeViewItems = require("../internals/plugins/useTreeViewItems/useTreeViewItems.selectors");
+var _useTreeViewItems = require("../internals/plugins/useTreeViewItems");
 const useTreeItemModel = itemId => {
   const {
     store
   } = (0, _TreeViewProvider.useTreeViewContext)();
-  return (0, _useSelector.useSelector)(store, _useTreeViewItems.selectorItemModel, itemId);
+  return (0, _store.useStore)(store, _useTreeViewItems.itemsSelectors.itemModel, itemId);
 };
 exports.useTreeItemModel = useTreeItemModel;