@mui/x-tree-view 8.0.0-alpha.11 → 8.0.0-alpha.13

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

@@ -1,36 +1,28 @@
-"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.useTreeViewSelection = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var React = _interopRequireWildcard(require("react"));
-var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedEffect"));
-var _tree = require("../../utils/tree");
-var _useTreeViewSelection = require("./useTreeViewSelection.utils");
-var _useTreeViewSelection2 = require("./useTreeViewSelection.selectors");
-var _useTreeViewSelection3 = require("./useTreeViewSelection.itemPlugin");
-const useTreeViewSelection = ({
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import { findOrderInTremauxTree, getAllNavigableItems, getFirstNavigableItem, getLastNavigableItem, getNonDisabledItemsInRange } from "../../utils/tree.js";
+import { convertSelectedItemsToArray, propagateSelection, getAddedAndRemovedItems, getLookupFromArray, createSelectedItemsMap } from "./useTreeViewSelection.utils.js";
+import { selectorIsItemSelected } from "./useTreeViewSelection.selectors.js";
+import { useTreeViewSelectionItemPlugin } from "./useTreeViewSelection.itemPlugin.js";
+export const useTreeViewSelection = ({
   store,
   params,
   models
 }) => {
   const lastSelectedItem = React.useRef(null);
   const lastSelectedRange = React.useRef({});
-  (0, _useEnhancedEffect.default)(() => {
-    store.update(prevState => (0, _extends2.default)({}, prevState, {
+  useEnhancedEffect(() => {
+    store.update(prevState => _extends({}, prevState, {
       selection: {
-        selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(models.selectedItems.value)
+        selectedItemsMap: createSelectedItemsMap(models.selectedItems.value)
       }
     }));
   }, [store, models.selectedItems.value]);
   const setSelectedItems = (event, newModel, additionalItemsToPropagate) => {
     let cleanModel;
     if (params.multiSelect && (params.selectionPropagation.descendants || params.selectionPropagation.parents)) {
-      cleanModel = (0, _useTreeViewSelection.propagateSelection)({
+      cleanModel = propagateSelection({
         store,
         selectionPropagation: params.selectionPropagation,
         newModel: newModel,
@@ -42,7 +34,7 @@ const useTreeViewSelection = ({
     }
     if (params.onItemSelectionToggle) {
       if (params.multiSelect) {
-        const changes = (0, _useTreeViewSelection.getAddedAndRemovedItems)({
+        const changes = getAddedAndRemovedItems({
           store,
           newModel: cleanModel,
           oldModel: models.selectedItems.value
@@ -80,8 +72,8 @@ const useTreeViewSelection = ({
     }
     let newSelected;
     if (keepExistingSelection) {
-      const cleanSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value);
-      const isSelectedBefore = (0, _useTreeViewSelection2.selectorIsItemSelected)(store.value, itemId);
+      const cleanSelectedItems = convertSelectedItemsToArray(models.selectedItems.value);
+      const isSelectedBefore = selectorIsItemSelected(store.value, itemId);
       if (isSelectedBefore && (shouldBeSelected === false || shouldBeSelected == null)) {
         newSelected = cleanSelectedItems.filter(id => id !== itemId);
       } else if (!isSelectedBefore && (shouldBeSelected === true || shouldBeSelected == null)) {
@@ -91,7 +83,7 @@ const useTreeViewSelection = ({
       }
     } else {
       // eslint-disable-next-line no-lonely-if
-      if (shouldBeSelected === false || shouldBeSelected == null && (0, _useTreeViewSelection2.selectorIsItemSelected)(store.value, itemId)) {
+      if (shouldBeSelected === false || shouldBeSelected == null && selectorIsItemSelected(store.value, itemId)) {
         newSelected = params.multiSelect ? [] : null;
       } else {
         newSelected = params.multiSelect ? [itemId] : itemId;
@@ -108,7 +100,7 @@ const useTreeViewSelection = ({
     if (params.disableSelection || !params.multiSelect) {
       return;
     }
-    let newSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value).slice();
+    let newSelectedItems = convertSelectedItemsToArray(models.selectedItems.value).slice();
 
     // If the last selection was a range selection,
     // remove the items that were part of the last range from the model
@@ -117,38 +109,38 @@ const useTreeViewSelection = ({
     }
 
     // Add to the model the items that are part of the new range and not already part of the model.
-    const selectedItemsLookup = (0, _useTreeViewSelection.getLookupFromArray)(newSelectedItems);
-    const range = (0, _tree.getNonDisabledItemsInRange)(store.value, start, end);
+    const selectedItemsLookup = getLookupFromArray(newSelectedItems);
+    const range = getNonDisabledItemsInRange(store.value, start, end);
     const itemsToAddToModel = range.filter(id => !selectedItemsLookup[id]);
     newSelectedItems = newSelectedItems.concat(itemsToAddToModel);
     setSelectedItems(event, newSelectedItems);
-    lastSelectedRange.current = (0, _useTreeViewSelection.getLookupFromArray)(range);
+    lastSelectedRange.current = getLookupFromArray(range);
   };
   const expandSelectionRange = (event, itemId) => {
     if (lastSelectedItem.current != null) {
-      const [start, end] = (0, _tree.findOrderInTremauxTree)(store.value, itemId, lastSelectedItem.current);
+      const [start, end] = findOrderInTremauxTree(store.value, itemId, lastSelectedItem.current);
       selectRange(event, [start, end]);
     }
   };
   const selectRangeFromStartToItem = (event, itemId) => {
-    selectRange(event, [(0, _tree.getFirstNavigableItem)(store.value), itemId]);
+    selectRange(event, [getFirstNavigableItem(store.value), itemId]);
   };
   const selectRangeFromItemToEnd = (event, itemId) => {
-    selectRange(event, [itemId, (0, _tree.getLastNavigableItem)(store.value)]);
+    selectRange(event, [itemId, getLastNavigableItem(store.value)]);
   };
   const selectAllNavigableItems = event => {
     if (params.disableSelection || !params.multiSelect) {
       return;
     }
-    const navigableItems = (0, _tree.getAllNavigableItems)(store.value);
+    const navigableItems = getAllNavigableItems(store.value);
     setSelectedItems(event, navigableItems);
-    lastSelectedRange.current = (0, _useTreeViewSelection.getLookupFromArray)(navigableItems);
+    lastSelectedRange.current = getLookupFromArray(navigableItems);
   };
   const selectItemFromArrowNavigation = (event, currentItem, nextItem) => {
     if (params.disableSelection || !params.multiSelect) {
       return;
     }
-    let newSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value).slice();
+    let newSelectedItems = convertSelectedItemsToArray(models.selectedItems.value).slice();
     if (Object.keys(lastSelectedRange.current).length === 0) {
       newSelectedItems.push(nextItem);
       lastSelectedRange.current = {
@@ -198,8 +190,7 @@ const useTreeViewSelection = ({
     contextValue: pluginContextValue
   };
 };
-exports.useTreeViewSelection = useTreeViewSelection;
-useTreeViewSelection.itemPlugin = _useTreeViewSelection3.useTreeViewSelectionItemPlugin;
+useTreeViewSelection.itemPlugin = useTreeViewSelectionItemPlugin;
 useTreeViewSelection.models = {
   selectedItems: {
     getDefaultValue: params => params.defaultSelectedItems
@@ -209,7 +200,7 @@ const DEFAULT_SELECTED_ITEMS = [];
 const EMPTY_SELECTION_PROPAGATION = {};
 useTreeViewSelection.getDefaultizedParams = ({
   params
-}) => (0, _extends2.default)({}, params, {
+}) => _extends({}, params, {
   disableSelection: params.disableSelection ?? false,
   multiSelect: params.multiSelect ?? false,
   checkboxSelection: params.checkboxSelection ?? false,
@@ -218,12 +209,12 @@ useTreeViewSelection.getDefaultizedParams = ({
 });
 useTreeViewSelection.getInitialState = params => ({
   selection: {
-    selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
+    selectedItemsMap: createSelectedItemsMap(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
   }
 });
 useTreeViewSelection.getInitialState = params => ({
   selection: {
-    selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
+    selectedItemsMap: createSelectedItemsMap(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
   }
 });
 useTreeViewSelection.params = {

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} params The params of the method.
+   * @param {React.SyntheticEvent} params.event The DOM event that triggered the change.
+   * @param {string} params.itemId The id of the item to select or deselect.
+   * @param {boolean} params.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} params.shouldBeSelected If `true` the item will be selected. If `false` the item will be deselected. If not defined, the item's new selection status will be the opposite of its current one.
+   */
+  selectItem: (params: {
+    event: React.SyntheticEvent;
+    itemId: string;
+    keepExistingSelection?: boolean;
+    shouldBeSelected?: 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.
+   * @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, 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.
+   * @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, 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>;