@mui/x-tree-view 7.0.0-alpha.8 → 7.0.0-beta.0

package/TreeView/TreeView.js

@@ -72,34 +72,13 @@ process.env.NODE_ENV !== "production" ? TreeView.propTypes = {
    * Override or extend the styles applied to the component.
    */
   classes: PropTypes.object,
-  /**
-   * className applied to the root element.
-   */
   className: PropTypes.string,
-  /**
-   * The default icon used to collapse the node.
-   */
-  defaultCollapseIcon: PropTypes.node,
-  /**
-   * The default icon displayed next to a end node. This is applied to all
-   * tree nodes and can be overridden by the TreeItem `icon` prop.
-   */
-  defaultEndIcon: PropTypes.node,
   /**
    * Expanded node ids.
    * Used when the item's expansion is not controlled.
    * @default []
    */
   defaultExpandedNodes: PropTypes.arrayOf(PropTypes.string),
-  /**
-   * The default icon used to expand the node.
-   */
-  defaultExpandIcon: PropTypes.node,
-  /**
-   * The default icon displayed next to a parent node. This is applied to all
-   * parent nodes and can be overridden by the TreeItem `icon` prop.
-   */
-  defaultParentIcon: PropTypes.node,
   /**
    * Selected node ids. (Uncontrolled)
    * When `multiSelect` is true this takes an array of strings; when false (default) a string.
@@ -121,24 +100,6 @@ process.env.NODE_ENV !== "production" ? TreeView.propTypes = {
    * Used when the item's expansion is controlled.
    */
   expandedNodes: PropTypes.arrayOf(PropTypes.string),
-  /**
-   * Used to determine the string label for a given item.
-   *
-   * @template R
-   * @param {R} item The item to check.
-   * @returns {string} The id of the item.
-   * @default `(item) => item.id`
-   */
-  getItemId: PropTypes.func,
-  /**
-   * Used to determine the string label for a given item.
-   *
-   * @template R
-   * @param {R} item The item to check.
-   * @returns {string} The label of the item.
-   * @default `(item) => item.label`
-   */
-  getItemLabel: PropTypes.func,
   /**
    * This prop is used to help implement the accessibility logic.
    * If you don't provide this prop. It falls back to a randomly generated id.

package/TreeView/TreeView.types.d.ts

@@ -1,5 +1,9 @@
-import { SimpleTreeViewProps } from '../SimpleTreeView';
+import { SimpleTreeViewProps, SimpleTreeViewSlotProps, SimpleTreeViewSlots } from '../SimpleTreeView';
 export interface TreeViewProps<Multiple extends boolean | undefined> extends SimpleTreeViewProps<Multiple> {
 }
+export interface TreeViewSlots extends SimpleTreeViewSlots {
+}
+export interface TreeViewSlotProps extends SimpleTreeViewSlotProps {
+}
 export type SingleSelectTreeViewProps = SimpleTreeViewProps<false>;
 export type MultiSelectTreeViewProps = SimpleTreeViewProps<true>;

package/TreeView/index.d.ts

@@ -1,3 +1,3 @@
 export * from './TreeView';
 export * from './treeViewClasses';
-export type { TreeViewProps, SingleSelectTreeViewProps, MultiSelectTreeViewProps, } from './TreeView.types';
+export type { TreeViewProps, SingleSelectTreeViewProps, MultiSelectTreeViewProps, TreeViewSlots, TreeViewSlotProps, } from './TreeView.types';

package/icons/icons.d.ts

@@ -0,0 +1,6 @@
+export declare const TreeViewExpandIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+    muiName: string;
+};
+export declare const TreeViewCollapseIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+    muiName: string;
+};

package/icons/icons.js

@@ -0,0 +1,9 @@
+import { createSvgIcon } from '@mui/material/utils';
+import * as React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+export const TreeViewExpandIcon = createSvgIcon( /*#__PURE__*/_jsx("path", {
+  d: "M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"
+}), 'TreeViewExpandIcon');
+export const TreeViewCollapseIcon = createSvgIcon( /*#__PURE__*/_jsx("path", {
+  d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
+}), 'TreeViewCollapseIcon');

package/icons/index.d.ts

@@ -0,0 +1 @@
+export * from './icons';

package/icons/index.js

@@ -0,0 +1 @@
+export * from './icons';

package/icons/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/icons/index.js",
+  "types": "./index.d.ts"
+}

package/index.d.ts

@@ -4,3 +4,4 @@ export * from './SimpleTreeView';
 export * from './RichTreeView';
 export { unstable_resetCleanupTracking } from './internals/hooks/useInstanceEventHandler';
 export * from './models';
+export * from './icons';

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-tree-view v7.0.0-alpha.8
+ * @mui/x-tree-view v7.0.0-beta.0
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
@@ -10,4 +10,5 @@ export * from './TreeView';
 export * from './SimpleTreeView';
 export * from './RichTreeView';
 export { unstable_resetCleanupTracking } from './internals/hooks/useInstanceEventHandler';
-export * from './models';
+export * from './models';
+export * from './icons';

package/internals/TreeViewProvider/TreeViewContext.d.ts

@@ -1,6 +1,8 @@
 import * as React from 'react';
-import { TreeViewContextValue } from './TreeViewProvider.types';
 /**
  * @ignore - internal component.
  */
-export declare const TreeViewContext: React.Context<TreeViewContextValue<any> | null>;
+export declare const TreeViewContext: React.Context<{
+    instance: {};
+    runItemPlugins: (options: import("../models").TreeViewItemPluginOptions) => Required<import("../models").TreeViewItemPluginResponse>;
+} | null>;

package/internals/TreeViewProvider/TreeViewProvider.types.d.ts

@@ -1,17 +1,9 @@
 import * as React from 'react';
-import { TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginOptions, TreeViewItemPluginResponse } from '../models';
-export interface TreeViewContextValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
+import { MergePluginsProperty, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginOptions, TreeViewItemPluginResponse } from '../models';
+export type TreeViewContextValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> = MergePluginsProperty<TPlugins, 'contextValue'> & {
     instance: TreeViewInstance<TPlugins>;
     runItemPlugins: (options: TreeViewItemPluginOptions) => Required<TreeViewItemPluginResponse>;
-    multiSelect: boolean;
-    disabledItemsFocusable: boolean;
-    icons: {
-        defaultCollapseIcon: React.ReactNode;
-        defaultExpandIcon: React.ReactNode;
-        defaultParentIcon: React.ReactNode;
-        defaultEndIcon: React.ReactNode;
-    };
-}
+};
 export interface TreeViewProviderProps<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
     value: TreeViewContextValue<TPlugins>;
     children: React.ReactNode;

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

@@ -17,5 +17,6 @@ export interface UseTreeViewInstanceEventsInstance {
      */
     $$publishEvent: (eventName: string, params: any) => void;
 }
-export type UseTreeViewInstanceEventsSignature = TreeViewPluginSignature<{}, {}, UseTreeViewInstanceEventsInstance, {}, {}, never, [
-]>;
+export type UseTreeViewInstanceEventsSignature = TreeViewPluginSignature<{
+    instance: UseTreeViewInstanceEventsInstance;
+}>;

package/internals/index.d.ts

@@ -0,0 +1,15 @@
+export { useTreeView } from './useTreeView';
+export { TreeViewProvider } from './TreeViewProvider';
+export type { TreeViewPlugin, TreeViewPluginSignature } from './models';
+export { DEFAULT_TREE_VIEW_PLUGINS } from './plugins/defaultPlugins';
+export type { DefaultTreeViewPlugins, DefaultTreeViewPluginSlots, DefaultTreeViewPluginSlotProps, } from './plugins/defaultPlugins';
+export type { DefaultTreeViewPluginParameters } from './plugins/defaultPlugins';
+export type { UseTreeViewExpansionSignature } from './plugins/useTreeViewExpansion';
+export type { UseTreeViewSelectionSignature } from './plugins/useTreeViewSelection';
+export type { UseTreeViewFocusSignature } from './plugins/useTreeViewFocus';
+export type { UseTreeViewKeyboardNavigationSignature } from './plugins/useTreeViewKeyboardNavigation';
+export type { UseTreeViewIdSignature } from './plugins/useTreeViewId';
+export type { UseTreeViewIconsSignature } from './plugins/useTreeViewIcons';
+export type { UseTreeViewNodesSignature } from './plugins/useTreeViewNodes';
+export type { UseTreeViewJSXNodesSignature } from './plugins/useTreeViewJSXNodes';
+export { extractPluginParamsFromProps } from './utils/extractPluginParamsFromProps';

package/internals/index.js

@@ -0,0 +1,4 @@
+export { useTreeView } from './useTreeView';
+export { TreeViewProvider } from './TreeViewProvider';
+export { DEFAULT_TREE_VIEW_PLUGINS } from './plugins/defaultPlugins';
+export { extractPluginParamsFromProps } from './utils/extractPluginParamsFromProps';

package/internals/models/helpers.d.ts

@@ -1,5 +1,7 @@
-import { TreeViewAnyPluginSignature, TreeViewPlugin } from './plugin';
+import type { TreeViewAnyPluginSignature, TreeViewPlugin } from './plugin';
 export type DefaultizedProps<P extends {}, RequiredProps extends keyof P, AdditionalProps extends {} = {}> = Omit<P, RequiredProps | keyof AdditionalProps> & Required<Pick<P, RequiredProps>> & AdditionalProps;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export type OptionalIfEmpty<A extends string, B> = keyof B extends never ? Partial<Record<A, B>> : IsAny<B> extends true ? Partial<Record<A, B>> : Record<A, B>;
 export type MergePluginsProperty<TPlugins extends readonly any[], TProperty extends keyof TreeViewAnyPluginSignature> = TPlugins extends readonly [plugin: infer P, ...otherPlugin: infer R] ? P extends TreeViewAnyPluginSignature ? P[TProperty] & MergePluginsProperty<R, TProperty> : {} : {};
 export type ConvertPluginsIntoSignatures<TPlugins extends readonly any[]> = TPlugins extends readonly [plugin: infer P, ...otherPlugin: infer R] ? P extends TreeViewPlugin<infer TSignature> ? [TSignature, ...ConvertPluginsIntoSignatures<R>] : ConvertPluginsIntoSignatures<R> : [];
 export interface MergePlugins<TPlugins extends readonly any[]> {
@@ -8,6 +10,10 @@ export interface MergePlugins<TPlugins extends readonly any[]> {
     params: MergePluginsProperty<TPlugins, 'params'>;
     defaultizedParams: MergePluginsProperty<TPlugins, 'defaultizedParams'>;
     dependantPlugins: MergePluginsProperty<TPlugins, 'dependantPlugins'>;
+    contextValue: MergePluginsProperty<TPlugins, 'contextValue'>;
+    slots: MergePluginsProperty<TPlugins, 'slots'>;
+    slotProps: MergePluginsProperty<TPlugins, 'slotProps'>;
     events: MergePluginsProperty<TPlugins, 'events'>;
     models: MergePluginsProperty<TPlugins, 'models'>;
 }
+export {};

package/internals/models/plugin.d.ts

@@ -1,8 +1,7 @@
 import * as React from 'react';
 import { EventHandlers } from '@mui/base/utils';
 import { TreeViewModel } from './treeView';
-import type { TreeViewContextValue } from '../TreeViewProvider';
-import type { MergePluginsProperty } from './helpers';
+import type { MergePluginsProperty, OptionalIfEmpty } from './helpers';
 import { TreeViewEventLookupElement } from './events';
 import type { TreeViewCorePluginsSignature } from '../corePlugins';
 import type { TreeItemProps } from '../../TreeItem';
@@ -10,32 +9,71 @@ export interface TreeViewPluginOptions<TSignature extends TreeViewAnyPluginSigna
     instance: TreeViewUsedInstance<TSignature>;
     params: TreeViewUsedDefaultizedParams<TSignature>;
     state: TreeViewUsedState<TSignature>;
+    slots: TSignature['slots'];
+    slotProps: TSignature['slotProps'];
     models: TreeViewUsedModels<TSignature>;
     setState: React.Dispatch<React.SetStateAction<TreeViewUsedState<TSignature>>>;
     rootRef: React.RefObject<HTMLUListElement>;
 }
 type TreeViewModelsInitializer<TSignature extends TreeViewAnyPluginSignature> = {
     [TControlled in keyof TSignature['models']]: {
-        controlledProp: TControlled;
-        defaultProp: keyof TSignature['params'];
+        getDefaultValue: (params: TSignature['defaultizedParams']) => Exclude<TSignature['defaultizedParams'][TControlled], undefined>;
     };
 };
-interface TreeViewResponse {
+type TreeViewResponse<TSignature extends TreeViewAnyPluginSignature> = {
     getRootProps?: <TOther extends EventHandlers = {}>(otherHandlers: TOther) => React.HTMLAttributes<HTMLUListElement>;
-    contextValue?: TreeViewContextValue<any>;
-}
-export type TreeViewPluginSignature<TParams extends {}, TDefaultizedParams extends {}, TInstance extends {}, TEvents extends {
-    [key in keyof TEvents]: TreeViewEventLookupElement;
-}, TState extends {}, TModelNames extends keyof TDefaultizedParams, TDependantPlugins extends readonly TreeViewAnyPluginSignature[]> = {
-    params: TParams;
-    defaultizedParams: TDefaultizedParams;
-    instance: TInstance;
-    state: TState;
-    models: {
-        [TControlled in TModelNames]-?: TreeViewModel<Exclude<TDefaultizedParams[TControlled], undefined>>;
+} & OptionalIfEmpty<'contextValue', TSignature['contextValue']>;
+export type TreeViewPluginSignature<T extends {
+    params?: {};
+    defaultizedParams?: {};
+    instance?: {};
+    events?: {
+        [key in keyof T['events']]: TreeViewEventLookupElement;
+    };
+    state?: {};
+    contextValue?: {};
+    slots?: {
+        [key in keyof T['slots']]: React.ElementType;
     };
-    events: TEvents;
-    dependantPlugins: TDependantPlugins;
+    slotProps?: {
+        [key in keyof T['slotProps']]: {} | (() => {});
+    };
+    modelNames?: keyof T['defaultizedParams'];
+    dependantPlugins?: readonly TreeViewAnyPluginSignature[];
+}> = {
+    params: T extends {
+        params: {};
+    } ? T['params'] : {};
+    defaultizedParams: T extends {
+        defaultizedParams: {};
+    } ? T['defaultizedParams'] : {};
+    instance: T extends {
+        instance: {};
+    } ? T['instance'] : {};
+    events: T extends {
+        events: {};
+    } ? T['events'] : {};
+    state: T extends {
+        state: {};
+    } ? T['state'] : {};
+    contextValue: T extends {
+        contextValue: {};
+    } ? T['contextValue'] : {};
+    slots: T extends {
+        slots: {};
+    } ? T['slots'] : {};
+    slotProps: T extends {
+        slotProps: {};
+    } ? T['slotProps'] : {};
+    models: T extends {
+        defaultizedParams: {};
+        modelNames: keyof T['defaultizedParams'];
+    } ? {
+        [TControlled in T['modelNames']]-?: TreeViewModel<Exclude<T['defaultizedParams'][TControlled], undefined>>;
+    } : {};
+    dependantPlugins: T extends {
+        dependantPlugins: Array<any>;
+    } ? T['dependantPlugins'] : [];
 };
 export type TreeViewAnyPluginSignature = {
     state: any;
@@ -44,6 +82,9 @@ export type TreeViewAnyPluginSignature = {
     defaultizedParams: any;
     dependantPlugins: any;
     events: any;
+    contextValue: any;
+    slots: any;
+    slotProps: any;
     models: any;
 };
 type TreeViewUsedPlugins<TSignature extends TreeViewAnyPluginSignature> = [
@@ -59,7 +100,10 @@ export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature>
     $$signature: TSignature;
 };
 type TreeViewUsedState<TSignature extends TreeViewAnyPluginSignature> = TSignature['state'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'state'>;
-export type TreeViewUsedModels<TSignature extends TreeViewAnyPluginSignature> = TSignature['models'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'models'>;
+type RemoveSetValue<Models extends Record<string, TreeViewModel<any>>> = {
+    [K in keyof Models]: Omit<Models[K], 'setValue'>;
+};
+export type TreeViewUsedModels<TSignature extends TreeViewAnyPluginSignature> = TSignature['models'] & RemoveSetValue<MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'models'>>;
 export type TreeViewUsedEvents<TSignature extends TreeViewAnyPluginSignature> = TSignature['events'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'events'>;
 export interface TreeViewItemPluginOptions {
     props: TreeItemProps;
@@ -83,7 +127,7 @@ export interface TreeViewItemPluginResponse {
 }
 export type TreeViewItemPlugin = (options: TreeViewItemPluginOptions) => void | TreeViewItemPluginResponse;
 export type TreeViewPlugin<TSignature extends TreeViewAnyPluginSignature> = {
-    (options: TreeViewPluginOptions<TSignature>): void | TreeViewResponse;
+    (options: TreeViewPluginOptions<TSignature>): void | TreeViewResponse<TSignature>;
     getDefaultizedParams?: (params: TreeViewUsedParams<TSignature>) => TSignature['defaultizedParams'];
     getInitialState?: (params: TreeViewUsedDefaultizedParams<TSignature>) => TSignature['state'];
     models?: TreeViewModelsInitializer<TSignature>;

package/internals/models/treeView.d.ts

@@ -1,4 +1,3 @@
-import * as React from 'react';
 import type { TreeViewAnyPluginSignature } from './plugin';
 import type { MergePluginsProperty } from './helpers';
 export interface TreeViewNode {
@@ -22,6 +21,6 @@ export interface TreeViewItemRange {
 export interface TreeViewModel<TValue> {
     name: string;
     value: TValue;
-    setValue: React.Dispatch<React.SetStateAction<TValue>>;
+    setControlledValue: (value: TValue | ((prevValue: TValue) => TValue)) => void;
 }
 export type TreeViewInstance<TSignatures extends readonly TreeViewAnyPluginSignature[]> = MergePluginsProperty<TSignatures, 'instance'>;

package/internals/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/internals/index.js",
+  "types": "./index.d.ts"
+}

package/internals/plugins/defaultPlugins.d.ts

@@ -3,9 +3,11 @@ import { UseTreeViewNodesParameters } from './useTreeViewNodes';
 import { UseTreeViewExpansionParameters } from './useTreeViewExpansion';
 import { UseTreeViewSelectionParameters } from './useTreeViewSelection';
 import { UseTreeViewFocusParameters } from './useTreeViewFocus';
-import { UseTreeViewContextValueBuilderParameters } from './useTreeViewContextValueBuilder';
-import { ConvertPluginsIntoSignatures } from '../models';
-export declare const DEFAULT_TREE_VIEW_PLUGINS: readonly [import("../models").TreeViewPlugin<import("./useTreeViewId").UseTreeViewIdSignature>, import("../models").TreeViewPlugin<import("./useTreeViewNodes").UseTreeViewNodesSignature>, import("../models").TreeViewPlugin<import("./useTreeViewExpansion").UseTreeViewExpansionSignature>, import("../models").TreeViewPlugin<import("./useTreeViewSelection").UseTreeViewSelectionSignature>, import("../models").TreeViewPlugin<import("./useTreeViewFocus").UseTreeViewFocusSignature>, import("../models").TreeViewPlugin<import("./useTreeViewKeyboardNavigation").UseTreeViewKeyboardNavigationSignature>, import("../models").TreeViewPlugin<import("./useTreeViewContextValueBuilder").UseTreeViewContextValueBuilderSignature>];
+import { UseTreeViewIconsParameters } from './useTreeViewIcons';
+import { ConvertPluginsIntoSignatures, MergePluginsProperty } from '../models';
+export declare const DEFAULT_TREE_VIEW_PLUGINS: readonly [import("../models").TreeViewPlugin<import("./useTreeViewId").UseTreeViewIdSignature>, import("../models").TreeViewPlugin<import("./useTreeViewNodes").UseTreeViewNodesSignature>, import("../models").TreeViewPlugin<import("./useTreeViewExpansion").UseTreeViewExpansionSignature>, import("../models").TreeViewPlugin<import("./useTreeViewSelection").UseTreeViewSelectionSignature>, import("../models").TreeViewPlugin<import("./useTreeViewFocus").UseTreeViewFocusSignature>, import("../models").TreeViewPlugin<import("./useTreeViewKeyboardNavigation").UseTreeViewKeyboardNavigationSignature>, import("../models").TreeViewPlugin<import("./useTreeViewIcons").UseTreeViewIconsSignature>];
 export type DefaultTreeViewPlugins = ConvertPluginsIntoSignatures<typeof DEFAULT_TREE_VIEW_PLUGINS>;
-export interface DefaultTreeViewPluginParameters<R extends {}, Multiple extends boolean | undefined> extends UseTreeViewIdParameters, UseTreeViewNodesParameters<R>, UseTreeViewExpansionParameters, UseTreeViewFocusParameters, UseTreeViewSelectionParameters<Multiple>, UseTreeViewContextValueBuilderParameters {
+export type DefaultTreeViewPluginSlots = MergePluginsProperty<DefaultTreeViewPlugins, 'slots'>;
+export type DefaultTreeViewPluginSlotProps = MergePluginsProperty<DefaultTreeViewPlugins, 'slotProps'>;
+export interface DefaultTreeViewPluginParameters<R extends {}, Multiple extends boolean | undefined> extends UseTreeViewIdParameters, UseTreeViewNodesParameters<R>, UseTreeViewExpansionParameters, UseTreeViewFocusParameters, UseTreeViewSelectionParameters<Multiple>, UseTreeViewIconsParameters {
 }

package/internals/plugins/defaultPlugins.js

@@ -4,7 +4,7 @@ import { useTreeViewExpansion } from './useTreeViewExpansion';
 import { useTreeViewSelection } from './useTreeViewSelection';
 import { useTreeViewFocus } from './useTreeViewFocus';
 import { useTreeViewKeyboardNavigation } from './useTreeViewKeyboardNavigation';
-import { useTreeViewContextValueBuilder } from './useTreeViewContextValueBuilder';
-export const DEFAULT_TREE_VIEW_PLUGINS = [useTreeViewId, useTreeViewNodes, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewContextValueBuilder];
+import { useTreeViewIcons } from './useTreeViewIcons';
+export const DEFAULT_TREE_VIEW_PLUGINS = [useTreeViewId, useTreeViewNodes, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewIcons];
 
 // We can't infer this type from the plugin, otherwise we would lose the generics.

package/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -7,6 +7,11 @@ export const useTreeViewExpansion = ({
   params,
   models
 }) => {
+  const setExpandedNodes = (event, value) => {
+    var _params$onExpandedNod;
+    (_params$onExpandedNod = params.onExpandedNodesChange) == null || _params$onExpandedNod.call(params, event, value);
+    models.expandedNodes.setControlledValue(value);
+  };
   const isNodeExpanded = React.useCallback(nodeId => {
     return Array.isArray(models.expandedNodes.value) ? models.expandedNodes.value.indexOf(nodeId) !== -1 : false;
   }, [models.expandedNodes.value]);
@@ -28,10 +33,7 @@ export const useTreeViewExpansion = ({
     if (params.onNodeExpansionToggle) {
       params.onNodeExpansionToggle(event, nodeId, !isExpandedBefore);
     }
-    if (params.onExpandedNodesChange) {
-      params.onExpandedNodesChange(event, newExpanded);
-    }
-    models.expandedNodes.setValue(newExpanded);
+    setExpandedNodes(event, newExpanded);
   });
   const expandAllSiblings = (event, nodeId) => {
     const node = instance.getNode(nodeId);
@@ -44,10 +46,7 @@ export const useTreeViewExpansion = ({
           params.onNodeExpansionToggle(event, newlyExpandedNodeId, true);
         });
       }
-      if (params.onExpandedNodesChange) {
-        params.onExpandedNodesChange(event, newExpanded);
-      }
-      models.expandedNodes.setValue(newExpanded);
+      setExpandedNodes(event, newExpanded);
     }
   };
   populateInstance(instance, {
@@ -59,8 +58,7 @@ export const useTreeViewExpansion = ({
 };
 useTreeViewExpansion.models = {
   expandedNodes: {
-    controlledProp: 'expandedNodes',
-    defaultProp: 'defaultExpandedNodes'
+    getDefaultValue: params => params.defaultExpandedNodes
   }
 };
 const DEFAULT_EXPANDED_NODES = [];

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

@@ -34,6 +34,10 @@ export interface UseTreeViewExpansionParameters {
     onNodeExpansionToggle?: (event: React.SyntheticEvent, nodeId: string, isExpanded: boolean) => void;
 }
 export type UseTreeViewExpansionDefaultizedParameters = DefaultizedProps<UseTreeViewExpansionParameters, 'defaultExpandedNodes'>;
-export type UseTreeViewExpansionSignature = TreeViewPluginSignature<UseTreeViewExpansionParameters, UseTreeViewExpansionDefaultizedParameters, UseTreeViewExpansionInstance, {}, {}, 'expandedNodes', [
-    UseTreeViewNodesSignature
-]>;
+export type UseTreeViewExpansionSignature = TreeViewPluginSignature<{
+    params: UseTreeViewExpansionParameters;
+    defaultizedParams: UseTreeViewExpansionDefaultizedParameters;
+    instance: UseTreeViewExpansionInstance;
+    modelNames: 'expandedNodes';
+    dependantPlugins: [UseTreeViewNodesSignature];
+}>;

package/internals/plugins/useTreeViewFocus/useTreeViewFocus.js

@@ -88,12 +88,6 @@ export const useTreeViewFocus = ({
 useTreeViewFocus.getInitialState = () => ({
   focusedNodeId: null
 });
-useTreeViewFocus.getDefaultizedParams = params => {
-  var _params$disabledItems;
-  return _extends({}, params, {
-    disabledItemsFocusable: (_params$disabledItems = params.disabledItemsFocusable) != null ? _params$disabledItems : false
-  });
-};
 useTreeViewFocus.params = {
   onNodeFocus: true
 };

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

@@ -22,9 +22,15 @@ export type UseTreeViewFocusDefaultizedParameters = UseTreeViewFocusParameters;
 export interface UseTreeViewFocusState {
     focusedNodeId: string | null;
 }
-export type UseTreeViewFocusSignature = TreeViewPluginSignature<UseTreeViewFocusParameters, UseTreeViewFocusParameters, UseTreeViewFocusInstance, {}, UseTreeViewFocusState, never, [
-    UseTreeViewIdSignature,
-    UseTreeViewNodesSignature,
-    UseTreeViewSelectionSignature,
-    UseTreeViewExpansionSignature
-]>;
+export type UseTreeViewFocusSignature = TreeViewPluginSignature<{
+    params: UseTreeViewFocusParameters;
+    defaultizedParams: UseTreeViewFocusDefaultizedParameters;
+    instance: UseTreeViewFocusInstance;
+    state: UseTreeViewFocusState;
+    dependantPlugins: [
+        UseTreeViewIdSignature,
+        UseTreeViewNodesSignature,
+        UseTreeViewSelectionSignature,
+        UseTreeViewExpansionSignature
+    ];
+}>;

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

@@ -0,0 +1,2 @@
+export { useTreeViewIcons } from './useTreeViewIcons';
+export type { UseTreeViewIconsSignature, UseTreeViewIconsParameters, UseTreeViewIconsDefaultizedParameters, } from './useTreeViewIcons.types';

package/internals/plugins/useTreeViewIcons/index.js

@@ -0,0 +1 @@
+export { useTreeViewIcons } from './useTreeViewIcons';

package/internals/plugins/useTreeViewIcons/useTreeViewIcons.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewPlugin } from '../../models';
+import { UseTreeViewIconsSignature } from './useTreeViewIcons.types';
+export declare const useTreeViewIcons: TreeViewPlugin<UseTreeViewIconsSignature>;

package/internals/plugins/useTreeViewIcons/useTreeViewIcons.js

@@ -0,0 +1,22 @@
+export const useTreeViewIcons = ({
+  slots,
+  slotProps
+}) => {
+  return {
+    contextValue: {
+      icons: {
+        slots: {
+          collapseIcon: slots.collapseIcon,
+          expandIcon: slots.expandIcon,
+          endIcon: slots.endIcon
+        },
+        slotProps: {
+          collapseIcon: slotProps.collapseIcon,
+          expandIcon: slotProps.expandIcon,
+          endIcon: slotProps.endIcon
+        }
+      }
+    }
+  };
+};
+useTreeViewIcons.params = {};

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

@@ -0,0 +1,43 @@
+import * as React from 'react';
+import { SlotComponentProps } from '@mui/base/utils';
+import { TreeViewPluginSignature } from '../../models';
+import { UseTreeViewNodesSignature } from '../useTreeViewNodes';
+import { UseTreeViewSelectionSignature } from '../useTreeViewSelection';
+export interface UseTreeViewIconsParameters {
+}
+export type UseTreeViewIconsDefaultizedParameters = UseTreeViewIconsParameters;
+interface UseTreeViewIconsSlots {
+    /**
+     * The default icon used to collapse the node.
+     */
+    collapseIcon?: React.ElementType;
+    /**
+     * The default icon used to expand the node.
+     */
+    expandIcon?: React.ElementType;
+    /**
+     * The default icon displayed next to an end node.
+     * This is applied to all tree nodes and can be overridden by the TreeItem `icon` slot prop.
+     */
+    endIcon?: React.ElementType;
+}
+interface UseTreeViewIconsSlotProps {
+    collapseIcon?: SlotComponentProps<'svg', {}, {}>;
+    expandIcon?: SlotComponentProps<'svg', {}, {}>;
+    endIcon?: SlotComponentProps<'svg', {}, {}>;
+}
+interface UseTreeViewIconsContextValue {
+    icons: {
+        slots: UseTreeViewIconsSlots;
+        slotProps: UseTreeViewIconsSlotProps;
+    };
+}
+export type UseTreeViewIconsSignature = TreeViewPluginSignature<{
+    params: UseTreeViewIconsParameters;
+    defaultizedParams: UseTreeViewIconsDefaultizedParameters;
+    contextValue: UseTreeViewIconsContextValue;
+    slots: UseTreeViewIconsSlots;
+    slotProps: UseTreeViewIconsSlotProps;
+    dependantPlugins: [UseTreeViewNodesSignature, UseTreeViewSelectionSignature];
+}>;
+export {};

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

@@ -13,5 +13,9 @@ export type UseTreeViewIdDefaultizedParameters = UseTreeViewIdParameters;
 export interface UseTreeViewIdState {
     focusedNodeId: string | null;
 }
-export type UseTreeViewIdSignature = TreeViewPluginSignature<UseTreeViewIdParameters, UseTreeViewIdDefaultizedParameters, UseTreeViewIdInstance, {}, UseTreeViewIdState, never, [
-]>;
+export type UseTreeViewIdSignature = TreeViewPluginSignature<{
+    params: UseTreeViewIdParameters;
+    defaultizedParams: UseTreeViewIdDefaultizedParameters;
+    instance: UseTreeViewIdInstance;
+    state: UseTreeViewIdState;
+}>;

package/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.js

@@ -12,11 +12,16 @@ export const useTreeViewJSXNodes = ({
   setState
 }) => {
   const insertJSXNode = useEventCallback(node => {
-    setState(prevState => _extends({}, prevState, {
-      nodeMap: _extends({}, prevState.nodeMap, {
-        [node.id]: node
-      })
-    }));
+    setState(prevState => {
+      if (prevState.nodeMap[node.id] != null) {
+        throw new Error(['MUI X: The Tree View component requires all items to have a unique `id` property.', 'Alternatively, you can use the `getItemId` prop to specify a custom id for each item.', `Tow items were provided with the same id in the \`items\` prop: "${node.id}"`].join('\n'));
+      }
+      return _extends({}, prevState, {
+        nodeMap: _extends({}, prevState.nodeMap, {
+          [node.id]: node
+        })
+      });
+    });
   });
   const removeJSXNode = useEventCallback(nodeId => {
     setState(prevState => {

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

@@ -10,7 +10,9 @@ export interface UseTreeViewNodesParameters {
 }
 export interface UseTreeViewNodesDefaultizedParameters {
 }
-export type UseTreeViewJSXNodesSignature = TreeViewPluginSignature<UseTreeViewNodesParameters, UseTreeViewNodesDefaultizedParameters, UseTreeViewNodesInstance, {}, {}, never, [
-    UseTreeViewNodesSignature,
-    UseTreeViewKeyboardNavigationSignature
-]>;
+export type UseTreeViewJSXNodesSignature = TreeViewPluginSignature<{
+    params: UseTreeViewNodesParameters;
+    defaultizedParams: UseTreeViewNodesDefaultizedParameters;
+    instance: UseTreeViewNodesInstance;
+    dependantPlugins: [UseTreeViewNodesSignature, UseTreeViewKeyboardNavigationSignature];
+}>;