@mui/x-tree-view 8.2.0 → 8.3.0

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

@@ -60,7 +60,7 @@ export interface UseTreeViewLazyLoadingParameters<R extends {}> {
   dataSource?: DataSource<R>;
   dataSourceCache?: DataSourceCache;
 }
-export type UseTreeViewLazyLoadingDefaultizedParameters<R extends {}> = DefaultizedProps<UseTreeViewLazyLoadingParameters<R>, 'dataSource'>;
+export type UseTreeViewLazyLoadingParametersWithDefaults<R extends {}> = DefaultizedProps<UseTreeViewLazyLoadingParameters<R>, 'dataSource'>;
 export interface UseTreeViewLazyLoadingState {
   lazyLoading: {
     enabled: boolean;
@@ -72,11 +72,10 @@ export interface UseTreeViewLazyLoadingState {
 }
 export type UseTreeViewLazyLoadingSignature = TreeViewPluginSignature<{
   params: UseTreeViewLazyLoadingParameters<any>;
-  defaultizedParams: UseTreeViewLazyLoadingDefaultizedParameters<any>;
+  paramsWithDefaults: UseTreeViewLazyLoadingParametersWithDefaults<any>;
   publicAPI: UseTreeViewLazyLoadingPublicAPI;
   instance: UseTreeViewLazyLoadingInstance;
   state: UseTreeViewLazyLoadingState;
-  experimentalFeatures: 'lazyLoading';
   dependencies: [UseTreeViewItemsSignature, UseTreeViewExpansionSignature, UseTreeViewSelectionSignature];
 }>;
 export {};

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

@@ -1,2 +1,2 @@
 export { useTreeViewSelection } from "./useTreeViewSelection.js";
-export type { UseTreeViewSelectionSignature, UseTreeViewSelectionParameters, UseTreeViewSelectionDefaultizedParameters } from "./useTreeViewSelection.types.js";
+export type { UseTreeViewSelectionSignature, UseTreeViewSelectionParameters, UseTreeViewSelectionParametersWithDefaults } from "./useTreeViewSelection.types.js";

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

@@ -1,17 +1,18 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
+import { useAssertModelConsistency } from '@mui/x-internals/useAssertModelConsistency';
 import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
 import { findOrderInTremauxTree, getAllNavigableItems, getFirstNavigableItem, getLastNavigableItem, getNonDisabledItemsInRange } from "../../utils/tree.js";
 import { propagateSelection, getAddedAndRemovedItems, getLookupFromArray } from "./useTreeViewSelection.utils.js";
 import { selectorIsItemSelected, selectorIsMultiSelectEnabled, selectorIsSelectionEnabled, selectorSelectionModel, selectorSelectionModelArray } from "./useTreeViewSelection.selectors.js";
 import { useTreeViewSelectionItemPlugin } from "./useTreeViewSelection.itemPlugin.js";
-import { useAssertModelConsistency } from "../../utils/models.js";
 export const useTreeViewSelection = ({
   store,
   params
 }) => {
   useAssertModelConsistency({
-    state: 'selectedItems',
+    componentName: 'Tree View',
+    propName: 'selectedItems',
     controlled: params.selectedItems,
     defaultValue: params.defaultSelectedItems
   });
@@ -203,7 +204,7 @@ export const useTreeViewSelection = ({
 useTreeViewSelection.itemPlugin = useTreeViewSelectionItemPlugin;
 const DEFAULT_SELECTED_ITEMS = [];
 const EMPTY_SELECTION_PROPAGATION = {};
-useTreeViewSelection.getDefaultizedParams = ({
+useTreeViewSelection.applyDefaultValuesToParams = ({
   params
 }) => _extends({}, params, {
   disableSelection: params.disableSelection ?? false,

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

@@ -112,7 +112,7 @@ export interface UseTreeViewSelectionParameters<Multiple extends boolean | undef
    */
   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 type UseTreeViewSelectionParametersWithDefaults<Multiple extends boolean> = DefaultizedProps<UseTreeViewSelectionParameters<Multiple>, 'disableSelection' | 'defaultSelectedItems' | 'multiSelect' | 'checkboxSelection' | 'selectionPropagation'>;
 export interface UseTreeViewSelectionState {
   selection: {
     selectedItems: TreeViewSelectionValue<boolean>;
@@ -124,7 +124,7 @@ export interface UseTreeViewSelectionState {
 }
 export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
   params: UseTreeViewSelectionParameters<any>;
-  defaultizedParams: UseTreeViewSelectionDefaultizedParameters<any>;
+  paramsWithDefaults: UseTreeViewSelectionParametersWithDefaults<any>;
   instance: UseTreeViewSelectionInstance;
   publicAPI: UseTreeViewSelectionPublicAPI;
   state: UseTreeViewSelectionState;

package/esm/internals/useTreeView/{extractPluginParamsFromProps.d.ts → useExtractPluginParamsFromProps.d.ts}

@@ -1,20 +1,19 @@
 import { ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewAnyPluginSignature, TreeViewPluginSignature } from "../models/index.js";
 import { UseTreeViewBaseProps } from "./useTreeView.types.js";
 import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
+export declare const useExtractPluginParamsFromProps: <TSignatures extends readonly TreeViewPluginSignature<any>[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
+  props: {
+    apiRef,
+    ...props
+  },
+  plugins
+}: ExtractPluginParamsFromPropsParameters<TSignatures, TProps>) => ExtractPluginParamsFromPropsReturnValue<TSignatures, TProps>;
 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'>;
+  pluginParams: MergeSignaturesProperty<TSignatures, 'paramsWithDefaults'>;
   forwardedProps: Omit<TProps, keyof MergeSignaturesProperty<TSignatures, 'params'>>;
 }
-export declare const extractPluginParamsFromProps: <TSignatures extends readonly TreeViewPluginSignature<any>[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
-  props: {
-    apiRef,
-    experimentalFeatures: inExperimentalFeatures,
-    ...props
-  },
-  plugins
-}: ExtractPluginParamsFromPropsParameters<TSignatures, TProps>) => ExtractPluginParamsFromPropsReturnValue<TSignatures, TProps>;
 export {};

package/esm/internals/useTreeView/useExtractPluginParamsFromProps.js

@@ -0,0 +1,51 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["apiRef"];
+import * as React from 'react';
+export const useExtractPluginParamsFromProps = _ref => {
+  let {
+      props: {
+        apiRef
+      },
+      plugins
+    } = _ref,
+    props = _objectWithoutPropertiesLoose(_ref.props, _excluded);
+  const paramsLookup = React.useMemo(() => {
+    const tempParamsLookup = {};
+    plugins.forEach(plugin => {
+      Object.assign(tempParamsLookup, plugin.params);
+    });
+    return tempParamsLookup;
+  }, [plugins]);
+  const {
+    forwardedProps,
+    pluginParams
+  } = React.useMemo(() => {
+    const tempPluginParams = {};
+    const tempForwardedProps = {};
+    Object.keys(props).forEach(propName => {
+      const prop = props[propName];
+      if (paramsLookup[propName]) {
+        tempPluginParams[propName] = prop;
+      } else {
+        tempForwardedProps[propName] = prop;
+      }
+    });
+    const pluginParamsWithDefaults = plugins.reduce((acc, plugin) => {
+      if (plugin.applyDefaultValuesToParams) {
+        return plugin.applyDefaultValuesToParams({
+          params: acc
+        });
+      }
+      return acc;
+    }, tempPluginParams);
+    return {
+      forwardedProps: tempForwardedProps,
+      pluginParams: pluginParamsWithDefaults
+    };
+  }, [plugins, props, paramsLookup]);
+  return {
+    forwardedProps,
+    pluginParams,
+    apiRef
+  };
+};

package/esm/internals/useTreeView/useTreeView.js

@@ -2,7 +2,7 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import useForkRef from '@mui/utils/useForkRef';
 import { TREE_VIEW_CORE_PLUGINS } from "../corePlugins/index.js";
-import { extractPluginParamsFromProps } from "./extractPluginParamsFromProps.js";
+import { useExtractPluginParamsFromProps } from "./useExtractPluginParamsFromProps.js";
 import { useTreeViewBuildContext } from "./useTreeViewBuildContext.js";
 import { TreeViewStore } from "../utils/TreeViewStore.js";
 function initializeInputApiRef(inputApiRef) {
@@ -38,9 +38,8 @@ export const useTreeView = ({
   const {
     pluginParams,
     forwardedProps,
-    apiRef,
-    experimentalFeatures
-  } = extractPluginParamsFromProps({
+    apiRef
+  } = useExtractPluginParamsFromProps({
     plugins,
     props
   });
@@ -76,7 +75,6 @@ export const useTreeView = ({
     const pluginResponse = plugin({
       instance,
       params: pluginParams,
-      experimentalFeatures,
       rootRef: innerRootRef,
       plugins,
       store: storeRef.current

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/index.js";
-import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, TreeViewPublicAPI, TreeViewExperimentalFeatures } from "../models/index.js";
+import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, TreeViewPublicAPI } 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,7 +9,6 @@ export interface UseTreeViewParameters<TSignatures extends readonly TreeViewAnyP
 }
 export interface UseTreeViewBaseProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
   apiRef: React.RefObject<TreeViewPublicAPI<TSignatures> | undefined> | undefined;
-  experimentalFeatures: TreeViewExperimentalFeatures<TSignatures>;
 }
 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

@@ -3,16 +3,12 @@ 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
-}: {
+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>;
   rootRef: React.RefObject<HTMLUListElement | null>;
-}) => TreeViewContextValue<TSignatures>;
+}
+export {};

package/esm/internals/useTreeView/useTreeViewBuildContext.js

@@ -1,11 +1,12 @@
 import * as React from 'react';
-export const useTreeViewBuildContext = ({
-  plugins,
-  instance,
-  publicAPI,
-  store,
-  rootRef
-}) => {
+export const useTreeViewBuildContext = parameters => {
+  const {
+    plugins,
+    instance,
+    publicAPI,
+    store,
+    rootRef
+  } = parameters;
   const runItemPlugins = React.useCallback(itemPluginProps => {
     let finalRootRef = null;
     let finalContentRef = null;

package/esm/internals/utils/cleanupTracking/TimerBasedCleanupTracking.d.ts

@@ -1,6 +1,6 @@
 import { CleanupTracking, UnregisterToken, UnsubscribeFn } from "./CleanupTracking.js";
 export declare class TimerBasedCleanupTracking implements CleanupTracking {
-  timeouts?: Map<number, NodeJS.Timeout> | undefined;
+  timeouts?: Map<number, number> | undefined;
   cleanupTimeout: number;
   constructor(timeout?: number);
   register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;

package/esm/internals/utils/tree.js

@@ -44,7 +44,7 @@ export const getPreviousNavigableItem = (state, itemId) => {
   let lastNavigableChild = getLastNavigableItemInArray(state, selectorItemOrderedChildrenIds(state, currentItemId));
   while (selectorIsItemExpanded(state, currentItemId) && lastNavigableChild != null) {
     currentItemId = lastNavigableChild;
-    lastNavigableChild = selectorItemOrderedChildrenIds(state, currentItemId).find(childId => selectorCanItemBeFocused(state, childId));
+    lastNavigableChild = getLastNavigableItemInArray(state, selectorItemOrderedChildrenIds(state, currentItemId));
   }
   return currentItemId;
 };

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-tree-view v8.2.0
+ * @mui/x-tree-view v8.3.0
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/internals/corePlugins/useTreeViewId/index.d.ts

@@ -1,2 +1,2 @@
 export { useTreeViewId } from "./useTreeViewId.js";
-export type { UseTreeViewIdSignature, UseTreeViewIdParameters, UseTreeViewIdDefaultizedParameters } from "./useTreeViewId.types.js";
+export type { UseTreeViewIdSignature, UseTreeViewIdParameters, UseTreeViewIdParametersWithDefaults } from "./useTreeViewId.types.js";

package/internals/corePlugins/useTreeViewId/useTreeViewId.types.d.ts

@@ -6,7 +6,7 @@ export interface UseTreeViewIdParameters {
    */
   id?: string;
 }
-export type UseTreeViewIdDefaultizedParameters = UseTreeViewIdParameters;
+export type UseTreeViewIdParametersWithDefaults = UseTreeViewIdParameters;
 export interface UseTreeViewIdState {
   id: {
     treeId: string | undefined;
@@ -15,6 +15,6 @@ export interface UseTreeViewIdState {
 }
 export type UseTreeViewIdSignature = TreeViewPluginSignature<{
   params: UseTreeViewIdParameters;
-  defaultizedParams: UseTreeViewIdDefaultizedParameters;
+  paramsWithDefaults: UseTreeViewIdParametersWithDefaults;
   state: UseTreeViewIdState;
 }>;

package/internals/index.d.ts

@@ -4,7 +4,7 @@ export { RichTreeViewItems } from "./components/RichTreeViewItems.js";
 export type { RichTreeViewItemsSlots, RichTreeViewItemsSlotProps } from "./components/RichTreeViewItems.js";
 export { unstable_resetCleanupTracking, useInstanceEventHandler } from "./hooks/useInstanceEventHandler.js";
 export { useSelector } from "./hooks/useSelector.js";
-export type { TreeViewPlugin, TreeViewPluginSignature, ConvertPluginsIntoSignatures, MergeSignaturesProperty, TreeViewPublicAPI, TreeViewState, TreeViewExperimentalFeatures, TreeViewItemMeta, TreeViewInstance, TreeViewItemPlugin, TreeViewUsedStore } from "./models/index.js";
+export type { TreeViewPlugin, TreeViewPluginSignature, ConvertPluginsIntoSignatures, MergeSignaturesProperty, TreeViewPublicAPI, TreeViewState, TreeViewItemMeta, TreeViewInstance, TreeViewItemPlugin, TreeViewUsedStore } from "./models/index.js";
 export type { TreeViewCorePluginParameters } from "./corePlugins/index.js";
 export { useTreeViewExpansion } from "./plugins/useTreeViewExpansion/index.js";
 export type { UseTreeViewExpansionSignature, UseTreeViewExpansionParameters } from "./plugins/useTreeViewExpansion/index.js";
@@ -18,7 +18,7 @@ export { useTreeViewItems, buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from
 export { selectorItemMetaLookup, selectorItemMeta, selectorItemIndex, selectorItemOrderedChildrenIds } from "./plugins/useTreeViewItems/useTreeViewItems.selectors.js";
 export type { UseTreeViewItemsSignature, UseTreeViewItemsParameters, UseTreeViewItemsState } from "./plugins/useTreeViewItems/index.js";
 export { useTreeViewLabel } from "./plugins/useTreeViewLabel/index.js";
-export { selectorIsItemBeingEdited, selectorIsAnyItemBeingEdited as selectorIsAnItemEdited } from "./plugins/useTreeViewLabel/useTreeViewLabel.selectors.js";
+export { selectorIsItemBeingEdited, selectorIsAnyItemBeingEdited } from "./plugins/useTreeViewLabel/useTreeViewLabel.selectors.js";
 export type { UseTreeViewLabelSignature, UseTreeViewLabelParameters } from "./plugins/useTreeViewLabel/index.js";
 export { selectorIsItemExpanded } from "./plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
 export { selectorIsItemSelected } from "./plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";

package/internals/index.js

@@ -57,7 +57,7 @@ Object.defineProperty(exports, "selectorGetTreeItemError", {
     return _useTreeViewLazyLoading.selectorGetTreeItemError;
   }
 });
-Object.defineProperty(exports, "selectorIsAnItemEdited", {
+Object.defineProperty(exports, "selectorIsAnyItemBeingEdited", {
   enumerable: true,
   get: function () {
     return _useTreeViewLabel2.selectorIsAnyItemBeingEdited;

package/internals/models/plugin.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { EventHandlers } from '@mui/utils/types';
-import { TreeViewExperimentalFeatures, TreeViewInstance } from "./treeView.js";
+import { TreeViewInstance } from "./treeView.js";
 import type { MergeSignaturesProperty, OptionalIfEmpty } from "./helpers.js";
 import { TreeViewEventLookupElement } from "./events.js";
 import type { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
@@ -15,8 +15,7 @@ export interface TreeViewPluginOptions<TSignature extends TreeViewAnyPluginSigna
   /**
    * The Tree View parameters after being processed with the default values.
    */
-  params: TreeViewUsedDefaultizedParams<TSignature>;
-  experimentalFeatures: TreeViewUsedExperimentalFeatures<TSignature>;
+  params: TreeViewUsedParamsWithDefaults<TSignature>;
   /**
    * The store that can be used to access the state of other plugins.
    */
@@ -35,12 +34,11 @@ type TreeViewResponse<TSignature extends TreeViewAnyPluginSignature> = {
 } & OptionalIfEmpty<'publicAPI', TSignature['publicAPI']> & OptionalIfEmpty<'instance', TSignature['instance']>;
 export type TreeViewPluginSignature<T extends {
   params?: {};
-  defaultizedParams?: {};
+  paramsWithDefaults?: {};
   instance?: {};
   publicAPI?: {};
   events?: { [key in keyof T['events']]: TreeViewEventLookupElement };
   state?: {};
-  experimentalFeatures?: string;
   dependencies?: readonly TreeViewAnyPluginSignature[];
   optionalDependencies?: readonly TreeViewAnyPluginSignature[];
 }> = {
@@ -53,9 +51,9 @@ export type TreeViewPluginSignature<T extends {
   /**
    * The params after being processed with the default values.
    */
-  defaultizedParams: T extends {
-    defaultizedParams: {};
-  } ? T['defaultizedParams'] : {};
+  paramsWithDefaults: T extends {
+    paramsWithDefaults: {};
+  } ? T['paramsWithDefaults'] : {};
   /**
    * An imperative api available for internal use.
    */
@@ -78,9 +76,6 @@ export type TreeViewPluginSignature<T extends {
   state: T extends {
     state: {};
   } ? T['state'] : {};
-  experimentalFeatures: T extends {
-    experimentalFeatures: string;
-  } ? { [key in T['experimentalFeatures']]?: boolean } : {};
   /**
    * Any plugins that this plugin depends on.
    */
@@ -98,17 +93,16 @@ export type TreeViewAnyPluginSignature = {
   state: any;
   instance: any;
   params: any;
-  defaultizedParams: any;
+  paramsWithDefaults: any;
   dependencies: any;
   optionalDependencies: any;
   events: any;
-  experimentalFeatures: any;
   publicAPI: any;
 };
 type TreeViewRequiredPlugins<TSignature extends TreeViewAnyPluginSignature> = [...TreeViewCorePluginSignatures, ...TSignature['dependencies']];
 type PluginPropertyWithDependencies<TSignature extends TreeViewAnyPluginSignature, TProperty extends keyof TreeViewAnyPluginSignature> = TSignature[TProperty] & MergeSignaturesProperty<TreeViewRequiredPlugins<TSignature>, TProperty> & Partial<MergeSignaturesProperty<TSignature['optionalDependencies'], TProperty>>;
 export type TreeViewUsedParams<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'params'>;
-export type TreeViewUsedDefaultizedParams<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'defaultizedParams'>;
+export type TreeViewUsedParamsWithDefaults<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'paramsWithDefaults'>;
 export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'instance'> & {
   /**
    * Private property only defined in TypeScript to be able to access the plugin signature from the instance object.
@@ -116,7 +110,6 @@ export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature>
   $$signature: TSignature;
 };
 export type TreeViewUsedStore<TSignature extends TreeViewAnyPluginSignature> = TreeViewStore<[TSignature, ...TSignature['dependencies']]>;
-type TreeViewUsedExperimentalFeatures<TSignature extends TreeViewAnyPluginSignature> = TreeViewExperimentalFeatures<[TSignature, ...TSignature['dependencies']], TSignature['optionalDependencies']>;
 export type TreeViewUsedEvents<TSignature extends TreeViewAnyPluginSignature> = TSignature['events'] & MergeSignaturesProperty<TreeViewRequiredPlugins<TSignature>, 'events'>;
 export type TreeItemWrapper<TSignatures extends readonly TreeViewAnyPluginSignature[]> = (params: {
   itemId: TreeViewItemId;
@@ -139,22 +132,20 @@ export type TreeViewPlugin<TSignature extends TreeViewAnyPluginSignature> = {
    *
    * @param {TreeViewUsedParams<TSignature>} options The options object.
    * @param {TreeViewUsedParams<TSignature>['params']} options.params The parameters before being processed with the default values.
-   * @param {TreeViewUsedExperimentalFeatures<TSignature>} options.experimentalFeatures An object containing the experimental feature flags.
-   * @returns {TSignature['defaultizedParams']} The parameters after being processed with the default values.
+   * @returns {TSignature['paramsWithDefaults']} The parameters after being processed with the default values.
    */
-  getDefaultizedParams?: (options: {
+  applyDefaultValuesToParams?: (options: {
     params: TreeViewUsedParams<TSignature>;
-    experimentalFeatures: TreeViewUsedExperimentalFeatures<TSignature>;
-  }) => TSignature['defaultizedParams'];
+  }) => TSignature['paramsWithDefaults'];
   /**
    * The initial state is computed after the default values are applied.
    * It sets up the state for the first render.
    * Other state modifications have to be done in effects and so could not be applied on the initial render.
    *
-   * @param {TreeViewUsedDefaultizedParams<TSignature>} params The parameters after being processed with the default values.
+   * @param {TreeViewUsedParamsWithDefaults<TSignature>} params The parameters after being processed with the default values.
    * @returns {TSignature['state']} The initial state of the plugin.
    */
-  getInitialState?: (params: TreeViewUsedDefaultizedParams<TSignature>) => TSignature['state'];
+  getInitialState?: (params: TreeViewUsedParamsWithDefaults<TSignature>) => TSignature['state'];
   /**
    * An object where each property used by the plugin is set to `true`.
    */

package/internals/models/treeView.d.ts

@@ -18,7 +18,6 @@ export interface TreeViewItemMeta {
 }
 export type TreeViewInstance<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'instance'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
 export type TreeViewPublicAPI<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'publicAPI'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
-export type TreeViewExperimentalFeatures<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TSignatures, ...TOptionalSignatures], 'experimentalFeatures'>;
 export type TreeViewStateCacheKey = {
   id: number;
 };

package/internals/plugins/useTreeViewExpansion/index.d.ts

@@ -1,2 +1,2 @@
 export { useTreeViewExpansion } from "./useTreeViewExpansion.js";
-export type { UseTreeViewExpansionSignature, UseTreeViewExpansionParameters, UseTreeViewExpansionDefaultizedParameters } from "./useTreeViewExpansion.types.js";
+export type { UseTreeViewExpansionSignature, UseTreeViewExpansionParameters, UseTreeViewExpansionParametersWithDefaults } from "./useTreeViewExpansion.types.js";

package/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -6,20 +6,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useTreeViewExpansion = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _useAssertModelConsistency = require("@mui/x-internals/useAssertModelConsistency");
 var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
 var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedEffect"));
 var _useTreeViewExpansion = require("./useTreeViewExpansion.selectors");
 var _useTreeViewExpansion2 = require("./useTreeViewExpansion.utils");
 var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
 var _publishTreeViewEvent = require("../../utils/publishTreeViewEvent");
-var _models = require("../../utils/models");
 const useTreeViewExpansion = ({
   instance,
   store,
   params
 }) => {
-  (0, _models.useAssertModelConsistency)({
-    state: 'expandedItems',
+  (0, _useAssertModelConsistency.useAssertModelConsistency)({
+    componentName: 'Tree View',
+    propName: 'expandedItems',
     controlled: params.expandedItems,
     defaultValue: params.defaultExpandedItems
   });
@@ -136,7 +137,7 @@ const useTreeViewExpansion = ({
 };
 exports.useTreeViewExpansion = useTreeViewExpansion;
 const DEFAULT_EXPANDED_ITEMS = [];
-useTreeViewExpansion.getDefaultizedParams = ({
+useTreeViewExpansion.applyDefaultValuesToParams = ({
   params
 }) => (0, _extends2.default)({}, params, {
   defaultExpandedItems: params.defaultExpandedItems ?? DEFAULT_EXPANDED_ITEMS

package/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.types.d.ts

@@ -71,7 +71,7 @@ export interface UseTreeViewExpansionParameters {
    */
   expansionTrigger?: 'content' | 'iconContainer';
 }
-export type UseTreeViewExpansionDefaultizedParameters = DefaultizedProps<UseTreeViewExpansionParameters, 'defaultExpandedItems'>;
+export type UseTreeViewExpansionParametersWithDefaults = DefaultizedProps<UseTreeViewExpansionParameters, 'defaultExpandedItems'>;
 export interface UseTreeViewExpansionState {
   expansion: {
     expandedItems: string[];
@@ -90,7 +90,7 @@ interface UseTreeViewExpansionEventLookup {
 }
 export type UseTreeViewExpansionSignature = TreeViewPluginSignature<{
   params: UseTreeViewExpansionParameters;
-  defaultizedParams: UseTreeViewExpansionDefaultizedParameters;
+  paramsWithDefaults: UseTreeViewExpansionParametersWithDefaults;
   instance: UseTreeViewExpansionInstance;
   publicAPI: UseTreeViewExpansionPublicAPI;
   modelNames: 'expandedItems';

package/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.utils.d.ts

@@ -1,6 +1,6 @@
-import { TreeViewUsedDefaultizedParams } from "../../models/index.js";
+import { TreeViewUsedParamsWithDefaults } from "../../models/index.js";
 import { UseTreeViewExpansionSignature } from "./useTreeViewExpansion.types.js";
 export declare const getExpansionTrigger: ({
   isItemEditable,
   expansionTrigger
-}: Pick<TreeViewUsedDefaultizedParams<UseTreeViewExpansionSignature>, "isItemEditable" | "expansionTrigger">) => "content" | "iconContainer";
+}: Pick<TreeViewUsedParamsWithDefaults<UseTreeViewExpansionSignature>, "isItemEditable" | "expansionTrigger">) => "content" | "iconContainer";

package/internals/plugins/useTreeViewFocus/index.d.ts

@@ -1,2 +1,2 @@
 export { useTreeViewFocus } from "./useTreeViewFocus.js";
-export type { UseTreeViewFocusSignature, UseTreeViewFocusParameters, UseTreeViewFocusDefaultizedParameters } from "./useTreeViewFocus.types.js";
+export type { UseTreeViewFocusSignature, UseTreeViewFocusParameters, UseTreeViewFocusParametersWithDefaults } from "./useTreeViewFocus.types.js";

package/internals/plugins/useTreeViewFocus/useTreeViewFocus.types.d.ts

@@ -28,7 +28,7 @@ export interface UseTreeViewFocusParameters {
    */
   onItemFocus?: (event: React.SyntheticEvent | null, itemId: string) => void;
 }
-export type UseTreeViewFocusDefaultizedParameters = UseTreeViewFocusParameters;
+export type UseTreeViewFocusParametersWithDefaults = UseTreeViewFocusParameters;
 export interface UseTreeViewFocusState {
   focus: {
     focusedItemId: string | null;
@@ -36,7 +36,7 @@ export interface UseTreeViewFocusState {
 }
 export type UseTreeViewFocusSignature = TreeViewPluginSignature<{
   params: UseTreeViewFocusParameters;
-  defaultizedParams: UseTreeViewFocusDefaultizedParameters;
+  paramsWithDefaults: UseTreeViewFocusParametersWithDefaults;
   instance: UseTreeViewFocusInstance;
   publicAPI: UseTreeViewFocusPublicAPI;
   state: UseTreeViewFocusState;

package/internals/plugins/useTreeViewItems/index.d.ts

@@ -1,3 +1,3 @@
 export { useTreeViewItems } from "./useTreeViewItems.js";
-export type { UseTreeViewItemsSignature, UseTreeViewItemsParameters, UseTreeViewItemsDefaultizedParameters, UseTreeViewItemsState } from "./useTreeViewItems.types.js";
+export type { UseTreeViewItemsSignature, UseTreeViewItemsParameters, UseTreeViewItemsParametersWithDefaults, UseTreeViewItemsState } from "./useTreeViewItems.types.js";
 export { buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from "./useTreeViewItems.utils.js";

package/internals/plugins/useTreeViewItems/useTreeViewItems.js

@@ -309,7 +309,7 @@ useTreeViewItems.getInitialState = params => ({
     error: null
   })
 });
-useTreeViewItems.getDefaultizedParams = ({
+useTreeViewItems.applyDefaultValuesToParams = ({
   params
 }) => (0, _extends2.default)({}, params, {
   disabledItemsFocusable: params.disabledItemsFocusable ?? false,

package/internals/plugins/useTreeViewItems/useTreeViewItems.types.d.ts

@@ -137,7 +137,7 @@ export interface UseTreeViewItemsParameters<R extends {
    */
   itemChildrenIndentation?: string | number;
 }
-export type UseTreeViewItemsDefaultizedParameters<R extends {
+export type UseTreeViewItemsParametersWithDefaults<R extends {
   children?: R[];
 }> = DefaultizedProps<UseTreeViewItemsParameters<R>, 'disabledItemsFocusable' | 'itemChildrenIndentation'>;
 interface UseTreeViewItemsEventLookup {
@@ -196,7 +196,7 @@ export interface UseTreeViewItemsState<R extends {}> {
 }
 export type UseTreeViewItemsSignature = TreeViewPluginSignature<{
   params: UseTreeViewItemsParameters<any>;
-  defaultizedParams: UseTreeViewItemsDefaultizedParameters<any>;
+  paramsWithDefaults: UseTreeViewItemsParametersWithDefaults<any>;
   instance: UseTreeViewItemsInstance<any>;
   publicAPI: UseTreeViewItemsPublicAPI<any>;
   events: UseTreeViewItemsEventLookup;

package/internals/plugins/useTreeViewJSXItems/index.d.ts

@@ -1,2 +1,2 @@
 export { useTreeViewJSXItems } from "./useTreeViewJSXItems.js";
-export type { UseTreeViewJSXItemsSignature, UseTreeViewJSXItemsParameters, UseTreeViewItemsDefaultizedParameters } from "./useTreeViewJSXItems.types.js";
+export type { UseTreeViewJSXItemsSignature, UseTreeViewJSXItemsParameters, UseTreeViewItemsParametersWithDefaults } from "./useTreeViewJSXItems.types.js";

package/internals/plugins/useTreeViewJSXItems/useTreeViewJSXItems.types.d.ts

@@ -26,10 +26,10 @@ export interface UseTreeViewItemsInstance {
   setJSXItemsOrderedChildrenIds: (parentId: TreeViewItemId | null, orderedChildrenIds: TreeViewItemId[]) => void;
 }
 export interface UseTreeViewJSXItemsParameters {}
-export interface UseTreeViewItemsDefaultizedParameters {}
+export interface UseTreeViewItemsParametersWithDefaults {}
 export type UseTreeViewJSXItemsSignature = TreeViewPluginSignature<{
   params: UseTreeViewJSXItemsParameters;
-  defaultizedParams: UseTreeViewItemsDefaultizedParameters;
+  paramsWithDefaults: UseTreeViewItemsParametersWithDefaults;
   instance: UseTreeViewItemsInstance;
   dependencies: [UseTreeViewItemsSignature, UseTreeViewKeyboardNavigationSignature];
 }>;

package/internals/plugins/useTreeViewLabel/useTreeViewLabel.js

@@ -61,7 +61,7 @@ const useTreeViewLabel = ({
 };
 exports.useTreeViewLabel = useTreeViewLabel;
 useTreeViewLabel.itemPlugin = _useTreeViewLabel.useTreeViewLabelItemPlugin;
-useTreeViewLabel.getDefaultizedParams = ({
+useTreeViewLabel.applyDefaultValuesToParams = ({
   params
 }) => (0, _extends2.default)({}, params, {
   isItemEditable: params.isItemEditable ?? false

package/internals/plugins/useTreeViewLabel/useTreeViewLabel.types.d.ts

@@ -35,7 +35,7 @@ export interface UseTreeViewLabelParameters<R extends {}> {
    */
   isItemEditable?: boolean | ((item: R) => boolean);
 }
-export type UseTreeViewLabelDefaultizedParameters<R extends {}> = DefaultizedProps<UseTreeViewLabelParameters<R>, 'isItemEditable'>;
+export type UseTreeViewLabelParametersWithDefaults<R extends {}> = DefaultizedProps<UseTreeViewLabelParameters<R>, 'isItemEditable'>;
 export interface UseTreeViewLabelState {
   label: {
     isItemEditable: ((item: any) => boolean) | boolean;
@@ -44,7 +44,7 @@ export interface UseTreeViewLabelState {
 }
 export type UseTreeViewLabelSignature = TreeViewPluginSignature<{
   params: UseTreeViewLabelParameters<any>;
-  defaultizedParams: UseTreeViewLabelDefaultizedParameters<any>;
+  paramsWithDefaults: UseTreeViewLabelParametersWithDefaults<any>;
   publicAPI: UseTreeViewLabelPublicAPI;
   instance: UseTreeViewLabelInstance;
   state: UseTreeViewLabelState;