@mui/x-tree-view 7.6.1 → 7.7.0

package/internals/TreeViewProvider/TreeViewContext.d.ts

@@ -3,10 +3,10 @@ import * as React from 'react';
  * @ignore - internal component.
  */
 export declare const TreeViewContext: React.Context<{
-    instance: {};
+    instance: import("../corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types").UseTreeViewInstanceEventsInstance;
     publicAPI: {};
     rootRef: React.RefObject<HTMLUListElement>;
     wrapItem: import("../models").TreeItemWrapper<any>;
     wrapRoot: import("../models").TreeRootWrapper<any>;
-    runItemPlugins: <TProps extends {}>(props: TProps) => Required<import("../models").TreeViewItemPluginResponse>;
+    runItemPlugins: import("./TreeViewProvider.types").TreeViewItemPluginsRunner;
 } | null>;

package/internals/TreeViewProvider/TreeViewProvider.d.ts

@@ -6,4 +6,4 @@ import { TreeViewAnyPluginSignature } from '../models';
  *
  * @ignore - do not document.
  */
-export declare function TreeViewProvider<TPlugins extends readonly TreeViewAnyPluginSignature[]>(props: TreeViewProviderProps<TPlugins>): React.JSX.Element;
+export declare function TreeViewProvider<TSignatures extends readonly TreeViewAnyPluginSignature[]>(props: TreeViewProviderProps<TSignatures>): React.JSX.Element;

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

@@ -1,14 +1,15 @@
 import * as React from 'react';
-import { MergePluginsProperty, TreeItemWrapper, TreeRootWrapper, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginResponse, TreeViewPublicAPI } from '../models';
-export type TreeViewContextValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> = MergePluginsProperty<TPlugins, 'contextValue'> & {
-    instance: TreeViewInstance<TPlugins>;
-    publicAPI: TreeViewPublicAPI<TPlugins>;
+import { MergeSignaturesProperty, TreeItemWrapper, TreeRootWrapper, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginResponse, TreeViewPublicAPI } from '../models';
+export type TreeViewItemPluginsRunner = <TProps extends {}>(props: TProps) => Required<TreeViewItemPluginResponse>;
+export type TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginSignature[]> = MergeSignaturesProperty<TSignatures, 'contextValue'> & {
+    instance: TreeViewInstance<TSignatures>;
+    publicAPI: TreeViewPublicAPI<TSignatures>;
     rootRef: React.RefObject<HTMLUListElement>;
-    wrapItem: TreeItemWrapper<TPlugins>;
-    wrapRoot: TreeRootWrapper<TPlugins>;
-    runItemPlugins: <TProps extends {}>(props: TProps) => Required<TreeViewItemPluginResponse>;
+    wrapItem: TreeItemWrapper<TSignatures>;
+    wrapRoot: TreeRootWrapper<TSignatures>;
+    runItemPlugins: TreeViewItemPluginsRunner;
 };
-export interface TreeViewProviderProps<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
-    value: TreeViewContextValue<TPlugins>;
+export interface TreeViewProviderProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
+    value: TreeViewContextValue<TSignatures>;
     children: React.ReactNode;
 }

package/internals/TreeViewProvider/index.d.ts

@@ -1,2 +1,2 @@
 export { TreeViewProvider } from './TreeViewProvider';
-export type { TreeViewProviderProps, TreeViewContextValue } from './TreeViewProvider.types';
+export type { TreeViewProviderProps, TreeViewContextValue, TreeViewItemPluginsRunner, } from './TreeViewProvider.types';

package/internals/TreeViewProvider/useTreeViewContext.d.ts

@@ -1,3 +1,3 @@
 import { TreeViewAnyPluginSignature } from '../models';
 import { TreeViewContextValue } from './TreeViewProvider.types';
-export declare const useTreeViewContext: <TPlugins extends readonly TreeViewAnyPluginSignature[]>() => NonNullable<TreeViewContextValue<TPlugins>>;
+export declare const useTreeViewContext: <TSignatures extends readonly TreeViewAnyPluginSignature[]>() => NonNullable<TreeViewContextValue<TSignatures>>;

package/internals/corePlugins/corePlugins.d.ts

@@ -1,7 +1,7 @@
-import { ConvertPluginsIntoSignatures, MergePlugins } from '../models';
+import { ConvertPluginsIntoSignatures } from '../models';
 /**
  * Internal plugins that create the tools used by the other plugins.
  * These plugins are used by the tree view components.
  */
 export declare const TREE_VIEW_CORE_PLUGINS: readonly [import("../models").TreeViewPlugin<import("./useTreeViewInstanceEvents").UseTreeViewInstanceEventsSignature>];
-export type TreeViewCorePluginsSignature = MergePlugins<ConvertPluginsIntoSignatures<typeof TREE_VIEW_CORE_PLUGINS>>;
+export type TreeViewCorePluginSignatures = ConvertPluginsIntoSignatures<typeof TREE_VIEW_CORE_PLUGINS>;

package/internals/corePlugins/index.d.ts

@@ -1,2 +1,2 @@
 export { TREE_VIEW_CORE_PLUGINS } from './corePlugins';
-export type { TreeViewCorePluginsSignature } from './corePlugins';
+export type { TreeViewCorePluginSignatures } from './corePlugins';

package/internals/hooks/useInstanceEventHandler.d.ts

@@ -7,9 +7,9 @@ interface RegistryContainer {
 }
 export declare function createUseInstanceEventHandler(registryContainer: RegistryContainer): <Instance extends UseTreeViewInstanceEventsInstance & {
     $$signature: TreeViewAnyPluginSignature;
-}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergePluginsProperty<[import("../corePlugins").TreeViewCorePluginsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, handler: TreeViewEventListener<TreeViewUsedEvents<Instance['$$signature']>[E]>) => void;
+}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergeSignaturesProperty<[import("../corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types").UseTreeViewInstanceEventsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, handler: TreeViewEventListener<TreeViewUsedEvents<Instance['$$signature']>[E]>) => void;
 export declare const unstable_resetCleanupTracking: () => void;
 export declare const useInstanceEventHandler: <Instance extends UseTreeViewInstanceEventsInstance & {
     $$signature: TreeViewAnyPluginSignature;
-}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergePluginsProperty<[import("../corePlugins").TreeViewCorePluginsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, handler: TreeViewEventListener<TreeViewUsedEvents<Instance['$$signature']>[E]>) => void;
+}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergeSignaturesProperty<[import("../corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types").UseTreeViewInstanceEventsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, handler: TreeViewEventListener<TreeViewUsedEvents<Instance['$$signature']>[E]>) => void;
 export {};

package/internals/index.d.ts

@@ -1,10 +1,7 @@
 export { useTreeView } from './useTreeView';
 export { TreeViewProvider } from './TreeViewProvider';
 export { unstable_resetCleanupTracking } from './hooks/useInstanceEventHandler';
-export type { TreeViewPlugin, TreeViewPluginSignature, ConvertPluginsIntoSignatures, MergePluginsProperty, TreeViewPublicAPI, TreeViewExperimentalFeatures, } 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 { TreeViewPlugin, TreeViewPluginSignature, ConvertPluginsIntoSignatures, MergeSignaturesProperty, TreeViewPublicAPI, TreeViewExperimentalFeatures, } from './models';
 export { useTreeViewExpansion } from './plugins/useTreeViewExpansion';
 export type { UseTreeViewExpansionSignature, UseTreeViewExpansionParameters, } from './plugins/useTreeViewExpansion';
 export { useTreeViewSelection } from './plugins/useTreeViewSelection';
@@ -22,4 +19,3 @@ export type { UseTreeViewItemsSignature, UseTreeViewItemsParameters, } from './p
 export { useTreeViewJSXItems } from './plugins/useTreeViewJSXItems';
 export type { UseTreeViewJSXItemsSignature, UseTreeViewJSXItemsParameters, } from './plugins/useTreeViewJSXItems';
 export { buildWarning } from './utils/warning';
-export { extractPluginParamsFromProps } from './utils/extractPluginParamsFromProps';

package/internals/index.js

@@ -2,7 +2,6 @@ export { useTreeView } from './useTreeView';
 export { TreeViewProvider } from './TreeViewProvider';
 export { unstable_resetCleanupTracking } from './hooks/useInstanceEventHandler';
 // Plugins
-export { DEFAULT_TREE_VIEW_PLUGINS } from './plugins/defaultPlugins';
 export { useTreeViewExpansion } from './plugins/useTreeViewExpansion';
 export { useTreeViewSelection } from './plugins/useTreeViewSelection';
 export { useTreeViewFocus } from './plugins/useTreeViewFocus';
@@ -11,5 +10,4 @@ export { useTreeViewId } from './plugins/useTreeViewId';
 export { useTreeViewIcons } from './plugins/useTreeViewIcons';
 export { useTreeViewItems } from './plugins/useTreeViewItems';
 export { useTreeViewJSXItems } from './plugins/useTreeViewJSXItems';
-export { buildWarning } from './utils/warning';
-export { extractPluginParamsFromProps } from './utils/extractPluginParamsFromProps';
+export { buildWarning } from './utils/warning';

package/internals/models/helpers.d.ts

@@ -3,20 +3,7 @@ export type DefaultizedProps<P extends {}, RequiredProps extends keyof P, Additi
 export type SlotComponentPropsFromProps<TProps extends {}, TOverrides extends {}, TOwnerState extends {}> = (Partial<TProps> & TOverrides) | ((ownerState: TOwnerState) => Partial<TProps> & TOverrides);
 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[]> {
-    state: MergePluginsProperty<TPlugins, 'state'>;
-    instance: MergePluginsProperty<TPlugins, 'instance'>;
-    publicAPI: MergePluginsProperty<TPlugins, 'publicAPI'>;
-    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'>;
-    experimentalFeatures: MergePluginsProperty<TPlugins, 'experimentalFeatures'>;
-}
+export type MergeSignaturesProperty<TSignatures extends readonly any[], TProperty extends keyof TreeViewAnyPluginSignature> = TSignatures extends readonly [plugin: infer P, ...otherPlugin: infer R] ? P extends TreeViewAnyPluginSignature ? P[TProperty] & MergeSignaturesProperty<R, TProperty> : {} : {};
+export type ConvertPluginsIntoSignatures<TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]> = TPlugins extends readonly [plugin: infer TPlugin, ...otherPlugin: infer R] ? R extends readonly TreeViewPlugin<any>[] ? TPlugin extends TreeViewPlugin<infer TSignature> ? readonly [TSignature, ...ConvertPluginsIntoSignatures<R>] : never : never : [];
+export type ConvertSignaturesIntoPlugins<TSignatures extends readonly TreeViewAnyPluginSignature[]> = TSignatures extends readonly [signature: infer TSignature, ...otherSignatures: infer R] ? R extends readonly TreeViewAnyPluginSignature[] ? TSignature extends TreeViewAnyPluginSignature ? readonly [TreeViewPlugin<TSignature>, ...ConvertSignaturesIntoPlugins<R>] : never : never : [];
 export {};

package/internals/models/plugin.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 import { EventHandlers } from '@mui/base/utils';
 import { TreeViewExperimentalFeatures, TreeViewInstance, TreeViewModel } from './treeView';
-import type { MergePluginsProperty, OptionalIfEmpty } from './helpers';
+import type { MergeSignaturesProperty, OptionalIfEmpty } from './helpers';
 import { TreeViewEventLookupElement } from './events';
-import type { TreeViewCorePluginsSignature } from '../corePlugins';
+import type { TreeViewCorePluginSignatures } from '../corePlugins';
 import { TreeViewItemId } from '../../models';
 export interface TreeViewPluginOptions<TSignature extends TreeViewAnyPluginSignature> {
     instance: TreeViewUsedInstance<TSignature>;
@@ -97,24 +97,24 @@ export type TreeViewAnyPluginSignature = {
     publicAPI: any;
 };
 type TreeViewUsedPlugins<TSignature extends TreeViewAnyPluginSignature> = [
-    TreeViewCorePluginsSignature,
+    ...TreeViewCorePluginSignatures,
     ...TSignature['dependantPlugins']
 ];
-export type TreeViewUsedParams<TSignature extends TreeViewAnyPluginSignature> = TSignature['params'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'params'>;
-type TreeViewUsedDefaultizedParams<TSignature extends TreeViewAnyPluginSignature> = TSignature['defaultizedParams'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'defaultizedParams'>;
-export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature> = TSignature['instance'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'instance'> & {
+export type TreeViewUsedParams<TSignature extends TreeViewAnyPluginSignature> = TSignature['params'] & MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'params'>;
+type TreeViewUsedDefaultizedParams<TSignature extends TreeViewAnyPluginSignature> = TSignature['defaultizedParams'] & MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'defaultizedParams'>;
+export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature> = TSignature['instance'] & MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'instance'> & {
     /**
      * Private property only defined in TypeScript to be able to access the plugin signature from the instance object.
      */
     $$signature: TSignature;
 };
-type TreeViewUsedState<TSignature extends TreeViewAnyPluginSignature> = TSignature['state'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'state'>;
+type TreeViewUsedState<TSignature extends TreeViewAnyPluginSignature> = TSignature['state'] & MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'state'>;
 type TreeViewUsedExperimentalFeatures<TSignature extends TreeViewAnyPluginSignature> = TreeViewExperimentalFeatures<[TSignature, ...TSignature['dependantPlugins']]>;
 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 type TreeViewUsedModels<TSignature extends TreeViewAnyPluginSignature> = TSignature['models'] & RemoveSetValue<MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'models'>>;
+export type TreeViewUsedEvents<TSignature extends TreeViewAnyPluginSignature> = TSignature['events'] & MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'events'>;
 export interface TreeViewItemPluginOptions<TProps extends {}> extends TreeViewItemPluginResponse {
     props: TProps;
 }

package/internals/models/treeView.d.ts

@@ -1,5 +1,6 @@
 import type { TreeViewAnyPluginSignature } from './plugin';
-import type { MergePluginsProperty } from './helpers';
+import type { MergeSignaturesProperty } from './helpers';
+import type { TreeViewCorePluginSignatures } from '../corePlugins';
 export interface TreeViewItemMeta {
     id: string;
     idAttribute: string | undefined;
@@ -20,8 +21,8 @@ export interface TreeViewModel<TValue> {
     value: TValue;
     setControlledValue: (value: TValue | ((prevValue: TValue) => TValue)) => void;
 }
-export type TreeViewInstance<TSignatures extends readonly TreeViewAnyPluginSignature[]> = MergePluginsProperty<TSignatures, 'instance'>;
-export type TreeViewPublicAPI<TSignatures extends readonly TreeViewAnyPluginSignature[]> = MergePluginsProperty<TSignatures, 'publicAPI'>;
+export type TreeViewInstance<TSignatures extends readonly TreeViewAnyPluginSignature[]> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'instance'>;
+export type TreeViewPublicAPI<TSignatures extends readonly TreeViewAnyPluginSignature[]> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'publicAPI'>;
 export type TreeViewExperimentalFeatures<TSignatures extends readonly TreeViewAnyPluginSignature[]> = {
-    [key in MergePluginsProperty<TSignatures, 'experimentalFeatures'>]?: boolean;
+    [key in MergeSignaturesProperty<TSignatures, 'experimentalFeatures'>]?: boolean;
 };

package/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { useTheme } from '@mui/material/styles';
+import { useRtl } from '@mui/system/RtlProvider';
 import useEventCallback from '@mui/utils/useEventCallback';
 import { getFirstNavigableItem, getLastNavigableItem, getNextNavigableItem, getPreviousNavigableItem } from '../../utils/tree';
 function isPrintableCharacter(string) {
@@ -10,8 +10,7 @@ export const useTreeViewKeyboardNavigation = ({
   params,
   state
 }) => {
-  const theme = useTheme();
-  const isRTL = theme.direction === 'rtl';
+  const isRtl = useRtl();
   const firstCharMap = React.useRef({});
   const updateFirstCharMap = useEventCallback(callback => {
     firstCharMap.current = callback(firstCharMap.current);
@@ -138,7 +137,7 @@ export const useTreeViewKeyboardNavigation = ({
 
       // If the focused item is expanded, we move the focus to its first child
       // If the focused item is collapsed and has children, we expand it
-      case key === 'ArrowRight' && !isRTL || key === 'ArrowLeft' && isRTL:
+      case key === 'ArrowRight' && !isRtl || key === 'ArrowLeft' && isRtl:
         {
           if (instance.isItemExpanded(itemId)) {
             const nextItemId = getNextNavigableItem(instance, itemId);
@@ -155,7 +154,7 @@ export const useTreeViewKeyboardNavigation = ({
 
       // If the focused item is expanded, we collapse it
       // If the focused item is collapsed and has a parent, we move the focus to this parent
-      case key === 'ArrowLeft' && !isRTL || key === 'ArrowRight' && isRTL:
+      case key === 'ArrowLeft' && !isRtl || key === 'ArrowRight' && isRtl:
         {
           if (canToggleItemExpansion(itemId) && instance.isItemExpanded(itemId)) {
             instance.toggleItemExpansion(event, itemId);

package/internals/useTreeView/extractPluginParamsFromProps.d.ts

@@ -0,0 +1,13 @@
+import { ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewAnyPluginSignature, TreeViewPluginSignature } from '../models';
+import { UseTreeViewBaseProps } from './useTreeView.types';
+import { TreeViewCorePluginSignatures } from '../corePlugins';
+interface ExtractPluginParamsFromPropsParameters<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> {
+    plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>;
+    props: TProps;
+}
+interface ExtractPluginParamsFromPropsReturnValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> extends UseTreeViewBaseProps<TSignatures> {
+    pluginParams: MergeSignaturesProperty<TSignatures, 'defaultizedParams'>;
+    forwardedProps: Omit<TProps, keyof MergeSignaturesProperty<TSignatures, 'params'>>;
+}
+export declare const extractPluginParamsFromProps: <TSignatures extends readonly TreeViewPluginSignature<any>[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({ props: { slots, slotProps, apiRef, experimentalFeatures, ...props }, plugins, }: ExtractPluginParamsFromPropsParameters<TSignatures, TProps>) => ExtractPluginParamsFromPropsReturnValue<TSignatures, TProps>;
+export {};

package/internals/{utils → useTreeView}/extractPluginParamsFromProps.js

@@ -8,35 +8,35 @@ export const extractPluginParamsFromProps = _ref => {
         apiRef,
         experimentalFeatures
       },
-      plugins,
-      rootRef
+      plugins
     } = _ref,
     props = _objectWithoutPropertiesLoose(_ref.props, _excluded);
   const paramsLookup = {};
   plugins.forEach(plugin => {
     Object.assign(paramsLookup, plugin.params);
   });
-  const pluginParams = {
-    plugins,
-    rootRef,
-    slots: slots ?? {},
-    slotProps: slotProps ?? {},
-    experimentalFeatures: experimentalFeatures ?? {},
-    apiRef
-  };
-  const otherProps = {};
+  const pluginParams = {};
+  const forwardedProps = {};
   Object.keys(props).forEach(propName => {
     const prop = props[propName];
     if (paramsLookup[propName]) {
       pluginParams[propName] = prop;
     } else {
-      otherProps[propName] = prop;
+      forwardedProps[propName] = prop;
     }
   });
+  const defaultizedPluginParams = plugins.reduce((acc, plugin) => {
+    if (plugin.getDefaultizedParams) {
+      return plugin.getDefaultizedParams(acc);
+    }
+    return acc;
+  }, pluginParams);
   return {
-    pluginParams,
-    slots,
-    slotProps,
-    otherProps
+    apiRef,
+    forwardedProps,
+    pluginParams: defaultizedPluginParams,
+    slots: slots ?? {},
+    slotProps: slotProps ?? {},
+    experimentalFeatures: experimentalFeatures ?? {}
   };
 };

package/internals/useTreeView/index.d.ts

@@ -1,2 +1 @@
 export { useTreeView } from './useTreeView';
-export type { UseTreeViewParameters, UseTreeViewDefaultizedParameters } from './useTreeView.types';

package/internals/useTreeView/useTreeView.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { TreeViewAnyPluginSignature, TreeViewPlugin, ConvertPluginsIntoSignatures } from '../models';
-import { UseTreeViewParameters, UseTreeViewReturnValue } from './useTreeView.types';
-export declare function useTreeViewApiInitialization<T>(inputApiRef: React.MutableRefObject<T> | undefined): T;
-export declare const useTreeView: <Plugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]>(inParams: UseTreeViewParameters<Plugins>) => UseTreeViewReturnValue<ConvertPluginsIntoSignatures<Plugins>>;
+import { TreeViewAnyPluginSignature } from '../models';
+import { UseTreeViewBaseProps, UseTreeViewParameters, UseTreeViewReturnValue } from './useTreeView.types';
+export declare function useTreeViewApiInitialization<T>(inputApiRef: React.MutableRefObject<T | undefined> | undefined): T;
+export declare const useTreeView: <TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({ plugins: inPlugins, rootRef, props, }: UseTreeViewParameters<TSignatures, TProps>) => UseTreeViewReturnValue<TSignatures>;

package/internals/useTreeView/useTreeView.js

@@ -3,6 +3,7 @@ import * as React from 'react';
 import useForkRef from '@mui/utils/useForkRef';
 import { useTreeViewModels } from './useTreeViewModels';
 import { TREE_VIEW_CORE_PLUGINS } from '../corePlugins';
+import { extractPluginParamsFromProps } from './extractPluginParamsFromProps';
 export function useTreeViewApiInitialization(inputApiRef) {
   const fallbackPublicApiRef = React.useRef({});
   if (inputApiRef) {
@@ -13,62 +14,69 @@ export function useTreeViewApiInitialization(inputApiRef) {
   }
   return fallbackPublicApiRef.current;
 }
-export const useTreeView = inParams => {
-  const plugins = [...TREE_VIEW_CORE_PLUGINS, ...inParams.plugins];
-  const params = plugins.reduce((acc, plugin) => {
-    if (plugin.getDefaultizedParams) {
-      return plugin.getDefaultizedParams(acc);
-    }
-    return acc;
-  }, inParams);
-  const models = useTreeViewModels(plugins, params);
+export const useTreeView = ({
+  plugins: inPlugins,
+  rootRef,
+  props
+}) => {
+  const plugins = [...TREE_VIEW_CORE_PLUGINS, ...inPlugins];
+  const {
+    pluginParams,
+    forwardedProps,
+    apiRef,
+    experimentalFeatures,
+    slots,
+    slotProps
+  } = extractPluginParamsFromProps({
+    plugins,
+    props
+  });
+  const models = useTreeViewModels(plugins, pluginParams);
   const instanceRef = React.useRef({});
   const instance = instanceRef.current;
-  const publicAPI = useTreeViewApiInitialization(inParams.apiRef);
+  const publicAPI = useTreeViewApiInitialization(apiRef);
   const innerRootRef = React.useRef(null);
-  const handleRootRef = useForkRef(innerRootRef, inParams.rootRef);
+  const handleRootRef = useForkRef(innerRootRef, rootRef);
   const [state, setState] = React.useState(() => {
     const temp = {};
     plugins.forEach(plugin => {
       if (plugin.getInitialState) {
-        Object.assign(temp, plugin.getInitialState(params));
+        Object.assign(temp, plugin.getInitialState(pluginParams));
       }
     });
     return temp;
   });
-  const rootPropsGetters = [];
-  const contextValue = {
-    publicAPI,
-    instance: instance,
-    rootRef: innerRootRef
+  const itemWrappers = plugins.map(plugin => plugin.wrapItem).filter(wrapItem => !!wrapItem);
+  const wrapItem = ({
+    itemId,
+    children
+  }) => {
+    let finalChildren = children;
+    itemWrappers.forEach(itemWrapper => {
+      finalChildren = itemWrapper({
+        itemId,
+        children: finalChildren,
+        instance
+      });
+    });
+    return finalChildren;
   };
-  const runPlugin = plugin => {
-    const pluginResponse = plugin({
-      instance,
-      params,
-      slots: params.slots,
-      slotProps: params.slotProps,
-      experimentalFeatures: params.experimentalFeatures,
-      state,
-      setState,
-      rootRef: innerRootRef,
-      models
+  const rootWrappers = plugins.map(plugin => plugin.wrapRoot).filter(wrapRoot => !!wrapRoot)
+  // The wrappers are reversed to ensure that the first wrapper is the outermost one.
+  .reverse();
+  const wrapRoot = ({
+    children
+  }) => {
+    let finalChildren = children;
+    rootWrappers.forEach(rootWrapper => {
+      finalChildren = rootWrapper({
+        children: finalChildren,
+        instance
+      });
     });
-    if (pluginResponse.getRootProps) {
-      rootPropsGetters.push(pluginResponse.getRootProps);
-    }
-    if (pluginResponse.publicAPI) {
-      Object.assign(publicAPI, pluginResponse.publicAPI);
-    }
-    if (pluginResponse.instance) {
-      Object.assign(instance, pluginResponse.instance);
-    }
-    if (pluginResponse.contextValue) {
-      Object.assign(contextValue, pluginResponse.contextValue);
-    }
+    return finalChildren;
   };
-  plugins.forEach(runPlugin);
-  contextValue.runItemPlugins = itemPluginProps => {
+  const runItemPlugins = itemPluginProps => {
     let finalRootRef = null;
     let finalContentRef = null;
     plugins.forEach(plugin => {
@@ -92,40 +100,45 @@ export const useTreeView = inParams => {
       rootRef: finalRootRef
     };
   };
-  const itemWrappers = plugins.map(plugin => plugin.wrapItem).filter(wrapItem => !!wrapItem);
-  contextValue.wrapItem = ({
-    itemId,
-    children
-  }) => {
-    let finalChildren = children;
-    itemWrappers.forEach(itemWrapper => {
-      finalChildren = itemWrapper({
-        itemId,
-        children: finalChildren,
-        instance
-      });
-    });
-    return finalChildren;
+  const contextValue = {
+    publicAPI,
+    wrapItem,
+    wrapRoot,
+    runItemPlugins,
+    instance: instance,
+    rootRef: innerRootRef
   };
-  const rootWrappers = plugins.map(plugin => plugin.wrapRoot).filter(wrapRoot => !!wrapRoot)
-  // The wrappers are reversed to ensure that the first wrapper is the outermost one.
-  .reverse();
-  contextValue.wrapRoot = ({
-    children
-  }) => {
-    let finalChildren = children;
-    rootWrappers.forEach(rootWrapper => {
-      finalChildren = rootWrapper({
-        children: finalChildren,
-        instance
-      });
+  const rootPropsGetters = [];
+  const runPlugin = plugin => {
+    const pluginResponse = plugin({
+      instance,
+      params: pluginParams,
+      slots,
+      slotProps,
+      experimentalFeatures,
+      state,
+      setState,
+      rootRef: innerRootRef,
+      models
     });
-    return finalChildren;
+    if (pluginResponse.getRootProps) {
+      rootPropsGetters.push(pluginResponse.getRootProps);
+    }
+    if (pluginResponse.publicAPI) {
+      Object.assign(publicAPI, pluginResponse.publicAPI);
+    }
+    if (pluginResponse.instance) {
+      Object.assign(instance, pluginResponse.instance);
+    }
+    if (pluginResponse.contextValue) {
+      Object.assign(contextValue, pluginResponse.contextValue);
+    }
   };
+  plugins.forEach(runPlugin);
   const getRootProps = (otherHandlers = {}) => {
     const rootProps = _extends({
       role: 'tree'
-    }, otherHandlers, {
+    }, forwardedProps, otherHandlers, {
       ref: handleRootRef
     });
     rootPropsGetters.forEach(rootPropsGetter => {
@@ -136,7 +149,7 @@ export const useTreeView = inParams => {
   return {
     getRootProps,
     rootRef: handleRootRef,
-    contextValue: contextValue,
-    instance: instance
+    contextValue,
+    instance
   };
 };

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

@@ -1,23 +1,24 @@
 import * as React from 'react';
 import { EventHandlers } from '@mui/base/utils';
 import type { TreeViewContextValue } from '../TreeViewProvider';
-import { TreeViewAnyPluginSignature, TreeViewPlugin, ConvertPluginsIntoSignatures, MergePluginsProperty, TreeViewInstance, TreeViewPublicAPI, TreeViewExperimentalFeatures } from '../models';
-export type UseTreeViewParameters<TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]> = UseTreeViewBaseParameters<TPlugins> & MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'params'>;
-export interface UseTreeViewBaseParameters<TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]> {
-    apiRef: React.MutableRefObject<TreeViewPublicAPI<ConvertPluginsIntoSignatures<TPlugins>>> | undefined;
+import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewInstance, TreeViewPublicAPI, TreeViewExperimentalFeatures } from '../models';
+export interface UseTreeViewParameters<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> {
+    plugins: ConvertSignaturesIntoPlugins<TSignatures>;
     rootRef?: React.Ref<HTMLUListElement> | undefined;
-    plugins: TPlugins;
-    slots: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'slots'>;
-    slotProps: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'slotProps'>;
-    experimentalFeatures: TreeViewExperimentalFeatures<ConvertPluginsIntoSignatures<TPlugins>>;
+    props: TProps;
+}
+export interface UseTreeViewBaseProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
+    apiRef: React.MutableRefObject<TreeViewPublicAPI<TSignatures> | undefined> | undefined;
+    slots: MergeSignaturesProperty<TSignatures, 'slots'>;
+    slotProps: MergeSignaturesProperty<TSignatures, 'slotProps'>;
+    experimentalFeatures: TreeViewExperimentalFeatures<TSignatures>;
 }
-export type UseTreeViewDefaultizedParameters<TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]> = UseTreeViewBaseParameters<TPlugins> & MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'defaultizedParams'>;
 export interface UseTreeViewRootSlotProps extends Pick<React.HTMLAttributes<HTMLUListElement>, 'onFocus' | 'onBlur' | 'onKeyDown' | 'id' | 'aria-multiselectable' | 'role' | 'tabIndex'> {
     ref: React.Ref<HTMLUListElement>;
 }
-export interface UseTreeViewReturnValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
+export interface UseTreeViewReturnValue<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
     getRootProps: <TOther extends EventHandlers = {}>(otherHandlers?: TOther) => UseTreeViewRootSlotProps;
     rootRef: React.RefCallback<HTMLUListElement> | null;
-    contextValue: TreeViewContextValue<TPlugins>;
-    instance: TreeViewInstance<TPlugins>;
+    contextValue: TreeViewContextValue<TSignatures>;
+    instance: TreeViewInstance<TSignatures>;
 }

package/internals/useTreeView/useTreeViewModels.d.ts

@@ -1,6 +1,7 @@
-import { TreeViewAnyPluginSignature, TreeViewPlugin, ConvertPluginsIntoSignatures, MergePluginsProperty } from '../models';
+import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty } from '../models';
+import { TreeViewCorePluginSignatures } from '../corePlugins';
 /**
  * Implements the same behavior as `useControlled` but for several models.
  * The controlled models are never stored in the state, and the state is only updated if the model is not controlled.
  */
-export declare const useTreeViewModels: <TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]>(plugins: TPlugins, props: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'defaultizedParams'>) => MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, "models">;
+export declare const useTreeViewModels: <TSignatures extends readonly TreeViewAnyPluginSignature[]>(plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>, props: MergeSignaturesProperty<TSignatures, 'defaultizedParams'>) => MergeSignaturesProperty<TSignatures, "models">;

package/internals/utils/publishTreeViewEvent.d.ts

@@ -2,4 +2,4 @@ import { UseTreeViewInstanceEventsInstance } from '../corePlugins/useTreeViewIns
 import { TreeViewAnyPluginSignature, TreeViewUsedEvents } from '../models';
 export declare const publishTreeViewEvent: <Instance extends UseTreeViewInstanceEventsInstance & {
     $$signature: TreeViewAnyPluginSignature;
-}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergePluginsProperty<[import("../corePlugins").TreeViewCorePluginsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, params: TreeViewUsedEvents<Instance['$$signature']>[E]['params']) => void;
+}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergeSignaturesProperty<[import("../corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types").UseTreeViewInstanceEventsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, params: TreeViewUsedEvents<Instance['$$signature']>[E]['params']) => void;

package/internals/zero-styled/index.d.ts

@@ -0,0 +1,3 @@
+import { useThemeProps } from '@mui/material/styles';
+export { styled } from '@mui/material/styles';
+export declare function createUseThemeProps(name: string): typeof useThemeProps;

package/internals/zero-styled/index.js

@@ -0,0 +1,7 @@
+import { useThemeProps } from '@mui/material/styles';
+export { styled } from '@mui/material/styles';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function createUseThemeProps(name) {
+  return useThemeProps;
+}