@mui/x-tree-view 7.6.2 → 7.7.1

package/hooks/useTreeItem2Utils/useTreeItem2Utils.js

@@ -5,6 +5,15 @@ const isItemExpandable = reactChildren => {
   }
   return Boolean(reactChildren);
 };
+
+/**
+ * Plugins that need to be present in the Tree View in order for `useTreeItem2Utils` to work correctly.
+ */
+
+/**
+ * Plugins that `useTreeItem2Utils` can use if they are present, but are not required.
+ */
+
 export const useTreeItem2Utils = ({
   itemId,
   children

package/hooks/useTreeViewApiRef.d.ts

@@ -3,4 +3,4 @@ import { TreeViewAnyPluginSignature, TreeViewPublicAPI } from '../internals/mode
 /**
  * Hook that instantiates a [[TreeViewApiRef]].
  */
-export declare const useTreeViewApiRef: <TPlugins extends readonly TreeViewAnyPluginSignature[] = [import("../internals").UseTreeViewIdSignature, import("../internals").UseTreeViewItemsSignature, import("../internals").UseTreeViewExpansionSignature, import("../internals").UseTreeViewSelectionSignature, import("../internals").UseTreeViewFocusSignature, import("../internals").UseTreeViewKeyboardNavigationSignature, import("../internals").UseTreeViewIconsSignature]>() => React.MutableRefObject<TreeViewPublicAPI<TPlugins> | undefined>;
+export declare const useTreeViewApiRef: <TSignatures extends readonly TreeViewAnyPluginSignature[] = readonly [import("../internals").UseTreeViewItemsSignature, import("../internals").UseTreeViewExpansionSignature, import("../internals").UseTreeViewSelectionSignature, import("../internals").UseTreeViewFocusSignature, import("../internals").UseTreeViewKeyboardNavigationSignature, import("../internals").UseTreeViewIconsSignature]>() => React.MutableRefObject<TreeViewPublicAPI<TSignatures> | undefined>;

package/index.js

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

package/internals/TreeViewProvider/TreeViewChildrenItemProvider.js

@@ -1,6 +1,7 @@
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { useTreeViewContext } from './useTreeViewContext';
+import { escapeOperandAttributeSelector } from '../utils/utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 export const TreeViewChildrenItemContext = /*#__PURE__*/React.createContext(null);
 if (process.env.NODE_ENV !== 'production') {
@@ -34,7 +35,8 @@ export function TreeViewChildrenItemProvider(props) {
       return;
     }
     const previousChildrenIds = instance.getItemOrderedChildrenIds(itemId ?? null) ?? [];
-    const childrenElements = rootRef.current.querySelectorAll(`${itemId == null ? '' : `*[id="${idAttr}"] `}[role="treeitem"]:not(*[id="${idAttr}"] [role="treeitem"] [role="treeitem"])`);
+    const escapedIdAttr = escapeOperandAttributeSelector(idAttr);
+    const childrenElements = rootRef.current.querySelectorAll(`${itemId == null ? '' : `*[id="${escapedIdAttr}"] `}[role="treeitem"]:not(*[id="${escapedIdAttr}"] [role="treeitem"] [role="treeitem"])`);
     const childrenIds = Array.from(childrenElements).map(child => childrenIdAttrToIdRef.current.get(child.id));
     const hasChanged = childrenIds.length !== previousChildrenIds.length || childrenIds.some((childId, index) => childId !== previousChildrenIds[index]);
     if (hasChanged) {

package/internals/TreeViewProvider/TreeViewContext.d.ts

@@ -1,12 +1,6 @@
 import * as React from 'react';
+import { TreeViewContextValue } from './TreeViewProvider.types';
 /**
  * @ignore - internal component.
  */
-export declare const TreeViewContext: React.Context<{
-    instance: {};
-    publicAPI: {};
-    rootRef: React.RefObject<HTMLUListElement>;
-    wrapItem: import("../models").TreeItemWrapper<any>;
-    wrapRoot: import("../models").TreeRootWrapper<any>;
-    runItemPlugins: <TProps extends {}>(props: TProps) => Required<import("../models").TreeViewItemPluginResponse>;
-} | null>;
+export declare const TreeViewContext: React.Context<TreeViewContextValue<any> | 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[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<TSignatures, 'contextValue'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'contextValue'>> & {
+    instance: TreeViewInstance<TSignatures, TOptionalSignatures>;
+    publicAPI: TreeViewPublicAPI<TSignatures, TOptionalSignatures>;
     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[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []>() => NonNullable<TreeViewContextValue<TSignatures, TOptionalSignatures>>;

package/internals/corePlugins/corePlugins.d.ts

@@ -1,7 +1,10 @@
-import { ConvertPluginsIntoSignatures, MergePlugins } from '../models';
+import { UseTreeViewIdParameters } from './useTreeViewId';
+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 declare const TREE_VIEW_CORE_PLUGINS: readonly [import("../models").TreeViewPlugin<import("./useTreeViewInstanceEvents").UseTreeViewInstanceEventsSignature>, import("../models").TreeViewPlugin<import("./useTreeViewId").UseTreeViewIdSignature>];
+export type TreeViewCorePluginSignatures = ConvertPluginsIntoSignatures<typeof TREE_VIEW_CORE_PLUGINS>;
+export interface TreeViewCorePluginParameters extends UseTreeViewIdParameters {
+}

package/internals/corePlugins/corePlugins.js

@@ -1,6 +1,7 @@
 import { useTreeViewInstanceEvents } from './useTreeViewInstanceEvents';
+import { useTreeViewId } from './useTreeViewId';
 /**
  * Internal plugins that create the tools used by the other plugins.
  * These plugins are used by the tree view components.
  */
-export const TREE_VIEW_CORE_PLUGINS = [useTreeViewInstanceEvents];
+export const TREE_VIEW_CORE_PLUGINS = [useTreeViewInstanceEvents, useTreeViewId];

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, TreeViewCorePluginParameters } from './corePlugins';

package/internals/{plugins → corePlugins}/useTreeViewId/useTreeViewId.types.d.ts

@@ -19,12 +19,8 @@ export interface UseTreeViewIdParameters {
     id?: string;
 }
 export type UseTreeViewIdDefaultizedParameters = UseTreeViewIdParameters;
-export interface UseTreeViewIdState {
-    focusedItemId: string | null;
-}
 export type UseTreeViewIdSignature = TreeViewPluginSignature<{
     params: UseTreeViewIdParameters;
     defaultizedParams: UseTreeViewIdDefaultizedParameters;
     instance: UseTreeViewIdInstance;
-    state: UseTreeViewIdState;
 }>;

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, import("../corePlugins/useTreeViewId").UseTreeViewIdSignature, ...Instance["$$signature"]["dependencies"]], "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, import("../corePlugins/useTreeViewId").UseTreeViewIdSignature, ...Instance["$$signature"]["dependencies"]], "events">>(instance: Instance, eventName: E, handler: TreeViewEventListener<TreeViewUsedEvents<Instance['$$signature']>[E]>) => void;
 export {};

package/internals/index.d.ts

@@ -1,10 +1,8 @@
 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 type { TreeViewCorePluginParameters } from './corePlugins';
 export { useTreeViewExpansion } from './plugins/useTreeViewExpansion';
 export type { UseTreeViewExpansionSignature, UseTreeViewExpansionParameters, } from './plugins/useTreeViewExpansion';
 export { useTreeViewSelection } from './plugins/useTreeViewSelection';
@@ -13,8 +11,6 @@ export { useTreeViewFocus } from './plugins/useTreeViewFocus';
 export type { UseTreeViewFocusSignature, UseTreeViewFocusParameters, } from './plugins/useTreeViewFocus';
 export { useTreeViewKeyboardNavigation } from './plugins/useTreeViewKeyboardNavigation';
 export type { UseTreeViewKeyboardNavigationSignature } from './plugins/useTreeViewKeyboardNavigation';
-export { useTreeViewId } from './plugins/useTreeViewId';
-export type { UseTreeViewIdSignature, UseTreeViewIdParameters } from './plugins/useTreeViewId';
 export { useTreeViewIcons } from './plugins/useTreeViewIcons';
 export type { UseTreeViewIconsSignature, UseTreeViewIconsParameters, } from './plugins/useTreeViewIcons';
 export { useTreeViewItems } from './plugins/useTreeViewItems';
@@ -22,4 +18,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

@@ -1,15 +1,15 @@
 export { useTreeView } from './useTreeView';
 export { TreeViewProvider } from './TreeViewProvider';
 export { unstable_resetCleanupTracking } from './hooks/useInstanceEventHandler';
+
+// Core plugins
+
 // Plugins
-export { DEFAULT_TREE_VIEW_PLUGINS } from './plugins/defaultPlugins';
 export { useTreeViewExpansion } from './plugins/useTreeViewExpansion';
 export { useTreeViewSelection } from './plugins/useTreeViewSelection';
 export { useTreeViewFocus } from './plugins/useTreeViewFocus';
 export { useTreeViewKeyboardNavigation } from './plugins/useTreeViewKeyboardNavigation';
-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>;
@@ -42,7 +42,8 @@ export type TreeViewPluginSignature<T extends {
     };
     modelNames?: keyof T['defaultizedParams'];
     experimentalFeatures?: string;
-    dependantPlugins?: readonly TreeViewAnyPluginSignature[];
+    dependencies?: readonly TreeViewAnyPluginSignature[];
+    optionalDependencies?: readonly TreeViewAnyPluginSignature[];
 }> = {
     params: T extends {
         params: {};
@@ -78,16 +79,20 @@ export type TreeViewPluginSignature<T extends {
         [TControlled in T['modelNames']]-?: TreeViewModel<Exclude<T['defaultizedParams'][TControlled], undefined>>;
     } : {};
     experimentalFeatures: T['experimentalFeatures'];
-    dependantPlugins: T extends {
-        dependantPlugins: Array<any>;
-    } ? T['dependantPlugins'] : [];
+    dependencies: T extends {
+        dependencies: Array<any>;
+    } ? T['dependencies'] : [];
+    optionalDependencies: T extends {
+        optionalDependencies: Array<any>;
+    } ? T['optionalDependencies'] : [];
 };
 export type TreeViewAnyPluginSignature = {
     state: any;
     instance: any;
     params: any;
     defaultizedParams: any;
-    dependantPlugins: any;
+    dependencies: any;
+    optionalDependencies: any;
     events: any;
     contextValue: any;
     slots: any;
@@ -96,25 +101,26 @@ export type TreeViewAnyPluginSignature = {
     experimentalFeatures: any;
     publicAPI: any;
 };
-type TreeViewUsedPlugins<TSignature extends TreeViewAnyPluginSignature> = [
-    TreeViewCorePluginsSignature,
-    ...TSignature['dependantPlugins']
+type TreeViewRequiredPlugins<TSignature extends TreeViewAnyPluginSignature> = [
+    ...TreeViewCorePluginSignatures,
+    ...TSignature['dependencies']
 ];
-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'> & {
+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'>;
+type TreeViewUsedDefaultizedParams<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'defaultizedParams'>;
+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.
      */
     $$signature: TSignature;
 };
-type TreeViewUsedState<TSignature extends TreeViewAnyPluginSignature> = TSignature['state'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'state'>;
-type TreeViewUsedExperimentalFeatures<TSignature extends TreeViewAnyPluginSignature> = TreeViewExperimentalFeatures<[TSignature, ...TSignature['dependantPlugins']]>;
+type TreeViewUsedState<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'state'>;
+type TreeViewUsedExperimentalFeatures<TSignature extends TreeViewAnyPluginSignature> = TreeViewExperimentalFeatures<[TSignature, ...TSignature['dependencies']]>;
 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<TreeViewRequiredPlugins<TSignature>, 'models'>>;
+export type TreeViewUsedEvents<TSignature extends TreeViewAnyPluginSignature> = TSignature['events'] & MergeSignaturesProperty<TreeViewRequiredPlugins<TSignature>, 'events'>;
 export interface TreeViewItemPluginOptions<TProps extends {}> extends TreeViewItemPluginResponse {
     props: TProps;
 }
@@ -150,12 +156,12 @@ export type TreeViewPlugin<TSignature extends TreeViewAnyPluginSignature> = {
      * @param {{ nodeId: TreeViewItemId; children: React.ReactNode; }} params The params of the item.
      * @returns {React.ReactNode} The wrapped item.
      */
-    wrapItem?: TreeItemWrapper<[TSignature, ...TSignature['dependantPlugins']]>;
+    wrapItem?: TreeItemWrapper<[TSignature, ...TSignature['dependencies']]>;
     /**
      * Render function used to add React wrappers around the TreeView.
      * @param {{ children: React.ReactNode; }} params The params of the root.
      * @returns {React.ReactNode} The wrapped root.
      */
-    wrapRoot?: TreeRootWrapper<[TSignature, ...TSignature['dependantPlugins']]>;
+    wrapRoot?: TreeRootWrapper<[TSignature, ...TSignature['dependencies']]>;
 };
 export {};

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[], 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[]> = {
-    [key in MergePluginsProperty<TSignatures, 'experimentalFeatures'>]?: boolean;
+    [key in MergeSignaturesProperty<TSignatures, 'experimentalFeatures'>]?: boolean;
 };

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

@@ -73,5 +73,5 @@ export type UseTreeViewExpansionSignature = TreeViewPluginSignature<{
     instance: UseTreeViewExpansionInstance;
     publicAPI: UseTreeViewExpansionPublicAPI;
     modelNames: 'expandedItems';
-    dependantPlugins: [UseTreeViewItemsSignature];
+    dependencies: [UseTreeViewItemsSignature];
 }>;

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

@@ -1,6 +1,5 @@
 import * as React from 'react';
 import { TreeViewPluginSignature } from '../../models';
-import { UseTreeViewIdSignature } from '../useTreeViewId/useTreeViewId.types';
 import type { UseTreeViewItemsSignature } from '../useTreeViewItems';
 import type { UseTreeViewSelectionSignature } from '../useTreeViewSelection';
 import { UseTreeViewExpansionSignature } from '../useTreeViewExpansion';
@@ -55,8 +54,7 @@ export type UseTreeViewFocusSignature = TreeViewPluginSignature<{
     instance: UseTreeViewFocusInstance;
     publicAPI: UseTreeViewFocusPublicAPI;
     state: UseTreeViewFocusState;
-    dependantPlugins: [
-        UseTreeViewIdSignature,
+    dependencies: [
         UseTreeViewItemsSignature,
         UseTreeViewSelectionSignature,
         UseTreeViewExpansionSignature

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

@@ -38,6 +38,6 @@ export type UseTreeViewIconsSignature = TreeViewPluginSignature<{
     contextValue: UseTreeViewIconsContextValue;
     slots: UseTreeViewIconsSlots;
     slotProps: UseTreeViewIconsSlotProps;
-    dependantPlugins: [UseTreeViewItemsSignature, UseTreeViewSelectionSignature];
+    dependencies: [UseTreeViewItemsSignature, UseTreeViewSelectionSignature];
 }>;
 export {};

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

@@ -33,5 +33,5 @@ export type UseTreeViewJSXItemsSignature = TreeViewPluginSignature<{
     params: UseTreeViewJSXItemsParameters;
     defaultizedParams: UseTreeViewItemsDefaultizedParameters;
     instance: UseTreeViewItemsInstance;
-    dependantPlugins: [UseTreeViewItemsSignature, UseTreeViewKeyboardNavigationSignature];
+    dependencies: [UseTreeViewItemsSignature, UseTreeViewKeyboardNavigationSignature];
 }>;

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/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.types.d.ts

@@ -24,7 +24,7 @@ export interface UseTreeViewKeyboardNavigationInstance {
 }
 export type UseTreeViewKeyboardNavigationSignature = TreeViewPluginSignature<{
     instance: UseTreeViewKeyboardNavigationInstance;
-    dependantPlugins: [
+    dependencies: [
         UseTreeViewItemsSignature,
         UseTreeViewSelectionSignature,
         UseTreeViewFocusSignature,

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

@@ -101,7 +101,7 @@ export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
     instance: UseTreeViewSelectionInstance;
     contextValue: UseTreeViewSelectionContextValue;
     modelNames: 'selectedItems';
-    dependantPlugins: [
+    dependencies: [
         UseTreeViewItemsSignature,
         UseTreeViewExpansionSignature,
         UseTreeViewItemsSignature

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>;