@mui/x-tree-view 8.0.0-beta.2 → 8.0.0

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

@@ -1,37 +1,203 @@
 import { TreeViewRootSelector } from "../../utils/selectors.js";
 import { UseTreeViewSelectionSignature } from "./useTreeViewSelection.types.js";
 /**
- * Check if an item is selected.
+ * Get the selected items.
  * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
- * @returns {boolean} `true` if the item is selected, `false` otherwise.
+ * @returns {TreeViewSelectionValue<boolean>} The selected items.
  */
-export declare const selectorIsItemSelected: ((state: any, itemId: string) => boolean) & {
+export declare const selectorSelectionModel: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => string | string[] | null) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
 } & {
   resultFunc: (resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
     selectionPropagation: import("../../..").TreeViewSelectionPropagation;
-  }, resultFuncArgs_1: string) => boolean;
+  }) => string | string[] | null;
   memoizedResultFunc: ((resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
     selectionPropagation: import("../../..").TreeViewSelectionPropagation;
-  }, resultFuncArgs_1: string) => boolean) & {
+  }) => string | string[] | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string | string[] | null;
+  dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * 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 declare const selectorSelectionModelArray: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => string[]) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: string | string[] | null) => string[];
+  memoizedResultFunc: ((resultFuncArgs_0: string | string[] | null) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string[];
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => string | string[] | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
+      isEnabled: boolean;
+      isMultiSelectEnabled: boolean;
+      isCheckboxSelectionEnabled: boolean;
+      selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+    }) => string | string[] | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
+      isEnabled: boolean;
+      isMultiSelectEnabled: boolean;
+      isCheckboxSelectionEnabled: boolean;
+      selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+    }) => string | string[] | null) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => string | string[] | null;
+    dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * 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: Map<string, true>, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: Map<string, true>, resultFuncArgs_1: string) => boolean) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
   };
   lastResult: () => boolean;
-  dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>, (_: any, itemId: string) => string];
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => Map<string, true>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: string[]) => Map<string, true>;
+    memoizedResultFunc: ((resultFuncArgs_0: string[]) => Map<string, true>) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => Map<string, true>;
+    dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+      cacheKey: import("../../models").TreeViewStateCacheKey;
+    }) => string[]) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    } & {
+      resultFunc: (resultFuncArgs_0: string | string[] | null) => string[];
+      memoizedResultFunc: ((resultFuncArgs_0: string | string[] | null) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+      };
+      lastResult: () => string[];
+      dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+        cacheKey: import("../../models").TreeViewStateCacheKey;
+      }) => string | string[] | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+      } & {
+        resultFunc: (resultFuncArgs_0: {
+          selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
+          isEnabled: boolean;
+          isMultiSelectEnabled: boolean;
+          isCheckboxSelectionEnabled: boolean;
+          selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+        }) => string | string[] | null;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+          selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
+          isEnabled: boolean;
+          isMultiSelectEnabled: boolean;
+          isCheckboxSelectionEnabled: boolean;
+          selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+        }) => string | string[] | null) & {
+          clearCache: () => void;
+          resultsCount: () => number;
+          resetResultsCount: () => void;
+        };
+        lastResult: () => string | string[] | null;
+        dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+      } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+      }];
+      recomputations: () => number;
+      resetRecomputations: () => void;
+      dependencyRecomputations: () => number;
+      resetDependencyRecomputations: () => void;
+    } & {
+      argsMemoize: typeof import("reselect").weakMapMemoize;
+      memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, (_: any, itemId: string) => string];
   recomputations: () => number;
   resetRecomputations: () => void;
   dependencyRecomputations: () => number;
@@ -53,16 +219,14 @@ export declare const selectorIsMultiSelectEnabled: ((state: import("../../corePl
   resetResultsCount: () => void;
 } & {
   resultFunc: (resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
     selectionPropagation: import("../../..").TreeViewSelectionPropagation;
   }) => boolean;
   memoizedResultFunc: ((resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
@@ -95,16 +259,14 @@ export declare const selectorIsSelectionEnabled: ((state: import("../../corePlug
   resetResultsCount: () => void;
 } & {
   resultFunc: (resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
     selectionPropagation: import("../../..").TreeViewSelectionPropagation;
   }) => boolean;
   memoizedResultFunc: ((resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
@@ -137,16 +299,14 @@ export declare const selectorIsCheckboxSelectionEnabled: ((state: import("../../
   resetResultsCount: () => void;
 } & {
   resultFunc: (resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
     selectionPropagation: import("../../..").TreeViewSelectionPropagation;
   }) => boolean;
   memoizedResultFunc: ((resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
@@ -282,16 +442,14 @@ export declare const selectorIsItemSelectionEnabled: ((state: any, itemId: strin
     resetResultsCount: () => void;
   } & {
     resultFunc: (resultFuncArgs_0: {
-      rawSelectedItems: string | string[] | null;
-      selectedItemsMap: Map<string, true>;
+      selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
       isEnabled: boolean;
       isMultiSelectEnabled: boolean;
       isCheckboxSelectionEnabled: boolean;
       selectionPropagation: import("../../..").TreeViewSelectionPropagation;
     }) => boolean;
     memoizedResultFunc: ((resultFuncArgs_0: {
-      rawSelectedItems: string | string[] | null;
-      selectedItemsMap: Map<string, true>;
+      selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
       isEnabled: boolean;
       isMultiSelectEnabled: boolean;
       isCheckboxSelectionEnabled: boolean;
@@ -332,16 +490,14 @@ export declare const selectorSelectionPropagationRules: ((state: import("../../c
   resetResultsCount: () => void;
 } & {
   resultFunc: (resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
     selectionPropagation: import("../../..").TreeViewSelectionPropagation;
   }) => import("../../..").TreeViewSelectionPropagation;
   memoizedResultFunc: ((resultFuncArgs_0: {
-    rawSelectedItems: string | string[] | null;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: import("./useTreeViewSelection.types").TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;

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

@@ -2,12 +2,47 @@ 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;
+  }
+  if (selectedItems != null) {
+    return [selectedItems];
+  }
+  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 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([selectorTreeViewSelectionState, (_, itemId) => itemId], (selectionState, itemId) => selectionState.selectedItemsMap.has(itemId));
+export const selectorIsItemSelected = createSelector([selectorSelectionModelMap, (_, itemId) => itemId], (selectedItemsMap, itemId) => selectedItemsMap.has(itemId));
 
 /**
  * Check if multi selection is enabled.

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

@@ -52,7 +52,7 @@ export interface UseTreeViewSelectionInstance extends UseTreeViewSelectionPublic
    */
   selectItemFromArrowNavigation: (event: React.SyntheticEvent, currentItemId: string, nextItemId: string) => void;
 }
-type TreeViewSelectionValue<Multiple extends boolean | undefined> = Multiple extends true ? string[] : string | null;
+export type TreeViewSelectionValue<Multiple extends boolean | undefined> = Multiple extends true ? string[] : string | null;
 export interface UseTreeViewSelectionParameters<Multiple extends boolean | undefined> {
   /**
    * If `true` selection is disabled.
@@ -115,8 +115,7 @@ export interface UseTreeViewSelectionParameters<Multiple extends boolean | undef
 export type UseTreeViewSelectionDefaultizedParameters<Multiple extends boolean> = DefaultizedProps<UseTreeViewSelectionParameters<Multiple>, 'disableSelection' | 'defaultSelectedItems' | 'multiSelect' | 'checkboxSelection' | 'selectionPropagation'>;
 export interface UseTreeViewSelectionState {
   selection: {
-    rawSelectedItems: TreeViewSelectionValue<boolean>;
-    selectedItemsMap: Map<string, true>;
+    selectedItems: TreeViewSelectionValue<boolean>;
     isEnabled: boolean;
     isMultiSelectEnabled: boolean;
     isCheckboxSelectionEnabled: boolean;
@@ -128,7 +127,6 @@ export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
   defaultizedParams: UseTreeViewSelectionDefaultizedParameters<any>;
   instance: UseTreeViewSelectionInstance;
   publicAPI: UseTreeViewSelectionPublicAPI;
-  modelNames: 'selectedItems';
   state: UseTreeViewSelectionState;
   dependencies: [UseTreeViewItemsSignature, UseTreeViewExpansionSignature, UseTreeViewItemsSignature];
 }>;
@@ -141,5 +139,4 @@ export interface UseTreeItemCheckboxSlotPropsFromSelection {
 }
 declare module '@mui/x-tree-view/useTreeItem' {
   interface UseTreeItemCheckboxSlotOwnProps extends UseTreeItemCheckboxSlotPropsFromSelection {}
-}
-export {};
+}

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

@@ -1,13 +1,6 @@
 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;
 };

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

@@ -1,27 +1,5 @@
 import { selectorIsItemSelected } from "./useTreeViewSelection.selectors.js";
 import { selectorItemOrderedChildrenIds, selectorItemParentId } from "../useTreeViewItems/useTreeViewItems.selectors.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 const convertSelectedItemsToArray = model => {
-  if (Array.isArray(model)) {
-    return model;
-  }
-  if (model != null) {
-    return [model];
-  }
-  return [];
-};
-export const createSelectedItemsMap = selectedItems => {
-  const selectedItemsMap = new Map();
-  convertSelectedItemsToArray(selectedItems).forEach(id => {
-    selectedItemsMap.set(id, true);
-  });
-  return selectedItemsMap;
-};
 export const getLookupFromArray = array => {
   const lookup = {};
   array.forEach(itemId => {
@@ -34,10 +12,13 @@ export const getAddedAndRemovedItems = ({
   oldModel,
   newModel
 }) => {
-  const newModelLookup = createSelectedItemsMap(newModel);
+  const newModelMap = new Map();
+  newModel.forEach(id => {
+    newModelMap.set(id, true);
+  });
   return {
     added: newModel.filter(itemId => !selectorIsItemSelected(store.value, itemId)),
-    removed: oldModel.filter(itemId => !newModelLookup.has(itemId))
+    removed: oldModel.filter(itemId => !newModelMap.has(itemId))
   };
 };
 export const propagateSelection = ({

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

@@ -11,8 +11,6 @@ interface ExtractPluginParamsFromPropsReturnValue<TSignatures extends readonly T
 }
 export declare const extractPluginParamsFromProps: <TSignatures extends readonly TreeViewPluginSignature<any>[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
   props: {
-    slots,
-    slotProps,
     apiRef,
     experimentalFeatures: inExperimentalFeatures,
     ...props

package/esm/internals/useTreeView/extractPluginParamsFromProps.js

@@ -1,10 +1,8 @@
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["slots", "slotProps", "apiRef", "experimentalFeatures"];
+const _excluded = ["apiRef", "experimentalFeatures"];
 export const extractPluginParamsFromProps = _ref => {
   let {
       props: {
-        slots,
-        slotProps,
         apiRef,
         experimentalFeatures: inExperimentalFeatures
       },
@@ -39,8 +37,6 @@ export const extractPluginParamsFromProps = _ref => {
     apiRef,
     forwardedProps,
     pluginParams: defaultizedPluginParams,
-    slots: slots ?? {},
-    slotProps: slotProps ?? {},
     experimentalFeatures
   };
 };

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

@@ -1,7 +1,16 @@
 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 function useTreeViewApiInitialization<T>(inputApiRef: React.RefObject<T | undefined> | undefined): React.RefObject<T>;
+/**
+ * This is the main hook that sets the plugin system up for the tree-view.
+ *
+ * It manages the data used to create the tree-view.
+ *
+ * @param plugins All the plugins that will be used in the tree-view.
+ * @param props The props passed to the tree-view.
+ * @param rootRef The ref of the root element.
+ */
 export declare const useTreeView: <TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
   plugins: inPlugins,
   rootRef,

package/esm/internals/useTreeView/useTreeView.js

@@ -1,22 +1,34 @@
 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";
+function initializeInputApiRef(inputApiRef) {
+  if (inputApiRef.current == null) {
+    inputApiRef.current = {};
+  }
+  return inputApiRef;
+}
 export function useTreeViewApiInitialization(inputApiRef) {
   const fallbackPublicApiRef = React.useRef({});
   if (inputApiRef) {
-    if (inputApiRef.current == null) {
-      inputApiRef.current = {};
-    }
-    return inputApiRef.current;
+    return initializeInputApiRef(inputApiRef);
   }
-  return fallbackPublicApiRef.current;
+  return fallbackPublicApiRef;
 }
 let globalId = 0;
+
+/**
+ * This is the main hook that sets the plugin system up for the tree-view.
+ *
+ * It manages the data used to create the tree-view.
+ *
+ * @param plugins All the plugins that will be used in the tree-view.
+ * @param props The props passed to the tree-view.
+ * @param rootRef The ref of the root element.
+ */
 export const useTreeView = ({
   plugins: inPlugins,
   rootRef,
@@ -27,14 +39,11 @@ export const useTreeView = ({
     pluginParams,
     forwardedProps,
     apiRef,
-    experimentalFeatures,
-    slots,
-    slotProps
+    experimentalFeatures
   } = extractPluginParamsFromProps({
     plugins,
     props
   });
-  const models = useTreeViewModels(plugins, pluginParams);
   const instanceRef = React.useRef({});
   const instance = instanceRef.current;
   const publicAPI = useTreeViewApiInitialization(apiRef);
@@ -55,24 +64,20 @@ export const useTreeView = ({
     });
     storeRef.current = new TreeViewStore(initialState);
   }
-  const baseContextValue = useTreeViewBuildContext({
+  const contextValue = useTreeViewBuildContext({
     plugins,
     instance,
-    publicAPI,
+    publicAPI: publicAPI.current,
     store: storeRef.current,
     rootRef: innerRootRef
   });
   const rootPropsGetters = [];
-  const pluginContextValues = [];
   const runPlugin = plugin => {
     const pluginResponse = plugin({
       instance,
       params: pluginParams,
-      slots,
-      slotProps,
       experimentalFeatures,
       rootRef: innerRootRef,
-      models,
       plugins,
       store: storeRef.current
     });
@@ -80,14 +85,11 @@ export const useTreeView = ({
       rootPropsGetters.push(pluginResponse.getRootProps);
     }
     if (pluginResponse.publicAPI) {
-      Object.assign(publicAPI, pluginResponse.publicAPI);
+      Object.assign(publicAPI.current, pluginResponse.publicAPI);
     }
     if (pluginResponse.instance) {
       Object.assign(instance, pluginResponse.instance);
     }
-    if (pluginResponse.contextValue) {
-      pluginContextValues.push(pluginResponse.contextValue);
-    }
   };
   plugins.forEach(runPlugin);
   const getRootProps = (otherHandlers = {}) => {
@@ -101,11 +103,6 @@ export const useTreeView = ({
     });
     return rootProps;
   };
-  const contextValue = React.useMemo(() => {
-    const copiedBaseContextValue = _extends({}, baseContextValue);
-    return Object.assign(copiedBaseContextValue, ...pluginContextValues);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [baseContextValue, ...pluginContextValues]);
   return {
     getRootProps,
     rootRef: handleRootRef,

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

@@ -1,7 +1,7 @@
 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";
+import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, 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;
@@ -9,8 +9,6 @@ export interface UseTreeViewParameters<TSignatures extends readonly TreeViewAnyP
 }
 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'> {

package/esm/internals/useTreeView/useTreeViewBuildContext.js

@@ -87,15 +87,13 @@ export const useTreeViewBuildContext = ({
     }
     return finalChildren;
   }, [plugins]);
-  return React.useMemo(() => {
-    return {
-      runItemPlugins,
-      wrapItem,
-      wrapRoot,
-      instance,
-      publicAPI,
-      store,
-      rootRef
-    };
-  }, [runItemPlugins, wrapItem, wrapRoot, instance, publicAPI, store, rootRef]);
+  return React.useMemo(() => ({
+    runItemPlugins,
+    wrapItem,
+    wrapRoot,
+    instance,
+    publicAPI,
+    store,
+    rootRef
+  }), [runItemPlugins, wrapItem, wrapRoot, instance, publicAPI, store, rootRef]);
 };

package/esm/internals/utils/models.d.ts

@@ -0,0 +1,7 @@
+declare function useAssertModelConsistencyOutsideOfProduction<T>(parameters: {
+  state: string;
+  controlled: T | undefined;
+  defaultValue: T;
+}): void;
+export declare const useAssertModelConsistency: typeof useAssertModelConsistencyOutsideOfProduction;
+export {};