@mui/x-tree-view 7.0.0-alpha.7 → 7.0.0-alpha.9

package/TreeItem/TreeItemContent.d.ts

@@ -1,8 +1,5 @@
 import * as React from 'react';
 export interface TreeItemContentProps extends React.HTMLAttributes<HTMLElement> {
-    /**
-     * className applied to the root element.
-     */
     className?: string;
     /**
      * Override or extend the styles applied to the component.

package/TreeItem/TreeItemContent.js

@@ -4,7 +4,7 @@ const _excluded = ["classes", "className", "displayIcon", "expansionIcon", "icon
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import clsx from 'clsx';
-import { useTreeItem } from './useTreeItem';
+import { useTreeItemState } from './useTreeItemState';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 /**
@@ -31,7 +31,7 @@ const TreeItemContent = /*#__PURE__*/React.forwardRef(function TreeItemContent(p
     handleExpansion,
     handleSelection,
     preventSelection
-  } = useTreeItem(nodeId);
+  } = useTreeItemState(nodeId);
   const icon = iconProp || expansionIcon || displayIcon;
   const handleMouseDown = event => {
     preventSelection(event);
@@ -73,9 +73,6 @@ process.env.NODE_ENV !== "production" ? TreeItemContent.propTypes = {
    * Override or extend the styles applied to the component.
    */
   classes: PropTypes.object.isRequired,
-  /**
-   * className applied to the root element.
-   */
   className: PropTypes.string,
   /**
    * The icon to display next to the tree node's label. Either a parent or end icon.

package/TreeItem/index.d.ts

@@ -1,6 +1,6 @@
 export { TreeItem } from './TreeItem';
-export type { TreeItemProps } from './TreeItem.types';
+export type { TreeItemProps, TreeItemSlots, TreeItemSlotProps } from './TreeItem.types';
 export * from './treeItemClasses';
-export * from './useTreeItem';
+export * from './useTreeItemState';
 export { TreeItemContent } from './TreeItemContent';
 export type { TreeItemContentProps, TreeItemContentClassKey } from './TreeItemContent';

package/TreeItem/index.js

@@ -1,4 +1,4 @@
 export { TreeItem } from './TreeItem';
 export * from './treeItemClasses';
-export * from './useTreeItem';
+export * from './useTreeItemState';
 export { TreeItemContent } from './TreeItemContent';

package/TreeItem/{useTreeItem.d.ts → useTreeItemState.d.ts}

@@ -1,5 +1,5 @@
 import * as React from 'react';
-export declare function useTreeItem(nodeId: string): {
+export declare function useTreeItemState(nodeId: string): {
     disabled: boolean;
     expanded: boolean;
     selected: boolean;

package/TreeItem/{useTreeItem.js → useTreeItemState.js}

@@ -1,8 +1,10 @@
 import { useTreeViewContext } from '../internals/TreeViewProvider/useTreeViewContext';
-export function useTreeItem(nodeId) {
+export function useTreeItemState(nodeId) {
   const {
     instance,
-    multiSelect
+    selection: {
+      multiSelect
+    }
   } = useTreeViewContext();
   const expandable = instance.isNodeExpandable(nodeId);
   const expanded = instance.isNodeExpanded(nodeId);

package/TreeView/TreeView.js

@@ -23,7 +23,7 @@ const TreeViewRoot = styled(SimpleTreeViewRoot, {
 let warnedOnce = false;
 const warn = () => {
   if (!warnedOnce) {
-    console.warn(['MUI: The TreeView component was renamed SimpleTreeView.', 'The component with the old naming will be removed in the version v8.0.0.', '', "You should use `import { SimpleTreeView } from '@mui/x-tree-view'`", "or `import { SimpleTreeView } from '@mui/x-tree-view/TreeView'`"].join('\n'));
+    console.warn(['MUI X: The TreeView component was renamed SimpleTreeView.', 'The component with the old naming will be removed in the version v8.0.0.', '', "You should use `import { SimpleTreeView } from '@mui/x-tree-view'`", "or `import { SimpleTreeView } from '@mui/x-tree-view/TreeView'`"].join('\n'));
     warnedOnce = true;
   }
 };
@@ -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.

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.7
+ * @mui/x-tree-view v7.0.0-alpha.9
  *
  * @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/TreeViewProvider/useTreeViewContext.js

@@ -3,7 +3,7 @@ import { TreeViewContext } from './TreeViewContext';
 export const useTreeViewContext = () => {
   const context = React.useContext(TreeViewContext);
   if (context == null) {
-    throw new Error(['MUI: Could not find the Tree View context.', 'It looks like you rendered your component outside of a SimpleTreeView or RichTreeView parent component.', 'This can also happen if you are bundling multiple versions of the Tree View.'].join('\n'));
+    throw new Error(['MUI X: Could not find the Tree View context.', 'It looks like you rendered your component outside of a SimpleTreeView or RichTreeView parent component.', 'This can also happen if you are bundling multiple versions of the Tree View.'].join('\n'));
   }
   return context;
 };

package/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.js

@@ -26,4 +26,5 @@ export const useTreeViewInstanceEvents = ({
     $$publishEvent: publishEvent,
     $$subscribeEvent: subscribeEvent
   });
-};
+};
+useTreeViewInstanceEvents.params = {};

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/MuiCancellableEvent.d.ts

@@ -0,0 +1,4 @@
+export type MuiCancellableEvent = {
+    defaultMuiPrevented?: boolean;
+};
+export type MuiCancellableEventHandler<Event> = (event: Event & MuiCancellableEvent) => void;

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,10 +127,11 @@ 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>;
+    params: Record<keyof TSignature['params'], true>;
     itemPlugin?: TreeViewItemPlugin;
 };
 export {};

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 = [];
@@ -69,4 +67,10 @@ useTreeViewExpansion.getDefaultizedParams = params => {
   return _extends({}, params, {
     defaultExpandedNodes: (_params$defaultExpand = params.defaultExpandedNodes) != null ? _params$defaultExpand : DEFAULT_EXPANDED_NODES
   });
+};
+useTreeViewExpansion.params = {
+  expandedNodes: true,
+  defaultExpandedNodes: true,
+  onExpandedNodesChange: true,
+  onNodeExpansionToggle: true
 };

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,9 +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>;