@mui/x-tree-view 8.0.0-beta.3 → 8.1.0

package/esm/SimpleTreeView/SimpleTreeView.types.d.ts

@@ -3,16 +3,17 @@ import { Theme } from '@mui/material/styles';
 import { SlotComponentProps } from '@mui/utils/types';
 import { SxProps } from '@mui/system/styleFunctionSx';
 import { SimpleTreeViewClasses } from "./simpleTreeViewClasses.js";
-import { SimpleTreeViewPluginParameters, SimpleTreeViewPluginSlotProps, SimpleTreeViewPluginSlots, SimpleTreeViewPluginSignatures } from "./SimpleTreeView.plugins.js";
+import { SimpleTreeViewPluginParameters, SimpleTreeViewPluginSignatures } from "./SimpleTreeView.plugins.js";
 import { TreeViewExperimentalFeatures, TreeViewPublicAPI } from "../internals/models/index.js";
-export interface SimpleTreeViewSlots extends SimpleTreeViewPluginSlots {
+import { TreeViewSlotProps, TreeViewSlots } from "../internals/TreeViewProvider/TreeViewStyleContext.js";
+export interface SimpleTreeViewSlots extends TreeViewSlots {
   /**
    * Element rendered at the root.
    * @default SimpleTreeViewRoot
    */
   root?: React.ElementType;
 }
-export interface SimpleTreeViewSlotProps extends SimpleTreeViewPluginSlotProps {
+export interface SimpleTreeViewSlotProps extends TreeViewSlotProps {
   root?: SlotComponentProps<'ul', {}, {}>;
 }
 export type SimpleTreeViewApiRef = React.RefObject<TreeViewPublicAPI<SimpleTreeViewPluginSignatures> | undefined>;

package/esm/TreeItem/TreeItem.js

@@ -27,8 +27,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const useThemeProps = createUseThemeProps('MuiTreeItem');
 export const TreeItemRoot = styled('li', {
   name: 'MuiTreeItem',
-  slot: 'Root',
-  overridesResolver: (props, styles) => styles.root
+  slot: 'Root'
 })({
   listStyle: 'none',
   margin: 0,
@@ -38,7 +37,6 @@ export const TreeItemRoot = styled('li', {
 export const TreeItemContent = styled('div', {
   name: 'MuiTreeItem',
   slot: 'Content',
-  overridesResolver: (props, styles) => styles.content,
   shouldForwardProp: prop => shouldForwardProp(prop) && prop !== 'status'
 })(({
   theme
@@ -86,7 +84,6 @@ export const TreeItemContent = styled('div', {
 export const TreeItemLabel = styled('div', {
   name: 'MuiTreeItem',
   slot: 'Label',
-  overridesResolver: (props, styles) => styles.label,
   shouldForwardProp: prop => shouldForwardProp(prop) && prop !== 'editable'
 })(({
   theme
@@ -110,8 +107,7 @@ export const TreeItemLabel = styled('div', {
 }));
 export const TreeItemIconContainer = styled('div', {
   name: 'MuiTreeItem',
-  slot: 'IconContainer',
-  overridesResolver: (props, styles) => styles.iconContainer
+  slot: 'IconContainer'
 })({
   width: 16,
   display: 'flex',
@@ -132,8 +128,7 @@ export const TreeItemGroupTransition = styled(Collapse, {
 });
 export const TreeItemErrorContainer = styled('div', {
   name: 'MuiTreeItem',
-  slot: 'ErrorIcon',
-  overridesResolver: (props, styles) => styles.errorIcon
+  slot: 'ErrorIcon'
 })({
   position: 'absolute',
   right: -3,
@@ -144,8 +139,7 @@ export const TreeItemErrorContainer = styled('div', {
 });
 export const TreeItemLoadingContainer = styled(CircularProgress, {
   name: 'MuiTreeItem',
-  slot: 'LoadingIcon',
-  overridesResolver: (props, styles) => styles.loadingIcon
+  slot: 'LoadingIcon'
 })({
   color: 'text.primary'
 });
@@ -162,8 +156,7 @@ export const TreeItemCheckbox = styled(/*#__PURE__*/React.forwardRef((props, ref
   }));
 }), {
   name: 'MuiTreeItem',
-  slot: 'Checkbox',
-  overridesResolver: (props, styles) => styles.checkbox
+  slot: 'Checkbox'
 })({
   padding: 0
 });

package/esm/TreeItemDragAndDropOverlay/TreeItemDragAndDropOverlay.js

@@ -10,7 +10,6 @@ import { jsx as _jsx } from "react/jsx-runtime";
 const TreeItemDragAndDropOverlayRoot = styled('div', {
   name: 'MuiTreeItemDragAndDropOverlay',
   slot: 'Root',
-  overridesResolver: (props, styles) => styles.root,
   shouldForwardProp: prop => shouldForwardProp(prop) && prop !== 'action'
 })(({
   theme

package/esm/TreeItemIcon/TreeItemIcon.js

@@ -5,21 +5,25 @@ import * as React from 'react';
 import PropTypes from 'prop-types';
 import resolveComponentProps from '@mui/utils/resolveComponentProps';
 import useSlotProps from '@mui/utils/useSlotProps';
-import { useTreeViewContext } from "../internals/TreeViewProvider/index.js";
+import { useTreeViewStyleContext } from "../internals/TreeViewProvider/TreeViewStyleContext.js";
 import { TreeViewCollapseIcon, TreeViewExpandIcon } from "../icons/index.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 function TreeItemIcon(props) {
   const {
-    slots,
-    slotProps,
+    slots: slotsFromTreeItem,
+    slotProps: slotPropsFromTreeItem,
     status
   } = props;
-  const context = useTreeViewContext();
-  const contextIcons = _extends({}, context.icons.slots, {
-    expandIcon: context.icons.slots.expandIcon ?? TreeViewExpandIcon,
-    collapseIcon: context.icons.slots.collapseIcon ?? TreeViewCollapseIcon
-  });
-  const contextIconProps = context.icons.slotProps;
+  const {
+    slots: slotsFromTreeView,
+    slotProps: slotPropsFromTreeView
+  } = useTreeViewStyleContext();
+  const slots = {
+    collapseIcon: slotsFromTreeItem?.collapseIcon ?? slotsFromTreeView.collapseIcon ?? TreeViewCollapseIcon,
+    expandIcon: slotsFromTreeItem?.expandIcon ?? slotsFromTreeView.expandIcon ?? TreeViewExpandIcon,
+    endIcon: slotsFromTreeItem?.endIcon ?? slotsFromTreeView.endIcon,
+    icon: slotsFromTreeItem?.icon
+  };
   let iconName;
   if (slots?.icon) {
     iconName = 'icon';
@@ -32,10 +36,10 @@ function TreeItemIcon(props) {
   } else {
     iconName = 'endIcon';
   }
-  const Icon = slots?.[iconName] ?? contextIcons[iconName];
+  const Icon = slots[iconName];
   const iconProps = useSlotProps({
     elementType: Icon,
-    externalSlotProps: tempOwnerState => _extends({}, resolveComponentProps(contextIconProps[iconName], tempOwnerState), resolveComponentProps(slotProps?.[iconName], tempOwnerState)),
+    externalSlotProps: tempOwnerState => _extends({}, resolveComponentProps(slotPropsFromTreeView[iconName], tempOwnerState), resolveComponentProps(slotPropsFromTreeItem?.[iconName], tempOwnerState)),
     // TODO: Add proper ownerState
     ownerState: {}
   });

package/esm/TreeItemLabelInput/TreeItemLabelInput.js

@@ -6,8 +6,7 @@ import { styled } from "../internals/zero-styled/index.js";
  */
 const TreeItemLabelInput = styled('input', {
   name: 'MuiTreeItem',
-  slot: 'LabelInput',
-  overridesResolver: (props, styles) => styles.labelInput
+  slot: 'LabelInput'
 })(({
   theme
 }) => _extends({}, theme.typography.body1, {

package/esm/hooks/useTreeItemUtils/useTreeItemUtils.js

@@ -79,7 +79,7 @@ export const useTreeItemUtils = ({
     if (status.disabled) {
       return;
     }
-    if (!status.focused) {
+    if (!status.focused && !status.editing) {
       instance.focusItem(event, itemId);
     }
     const multiple = isMultiSelectEnabled && (event.shiftKey || event.ctrlKey || event.metaKey);

package/esm/index.js

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

package/esm/internals/TreeViewProvider/TreeViewContext.d.ts

@@ -4,5 +4,5 @@ import { TreeViewContextValue } from "./TreeViewProvider.types.js";
 /**
  * @ignore - internal component.
  */
-export declare const TreeViewContext: React.Context<TreeViewContextValue<any> | null>;
+export declare const TreeViewContext: React.Context<TreeViewContextValue<any, []> | null>;
 export declare const useTreeViewContext: <TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []>() => TreeViewContextValue<TSignatures, TOptionalSignatures>;

package/esm/internals/TreeViewProvider/TreeViewProvider.js

@@ -13,13 +13,23 @@ export function TreeViewProvider(props) {
   const {
     contextValue,
     classes = EMPTY_OBJECT,
+    slots = EMPTY_OBJECT,
+    slotProps = EMPTY_OBJECT,
     children
   } = props;
-
-  // TODO: Add the icons to this context and drop useTreeViewIcons
   const styleContextValue = React.useMemo(() => ({
-    classes
-  }), [classes]);
+    classes,
+    slots: {
+      collapseIcon: slots.collapseIcon,
+      expandIcon: slots.expandIcon,
+      endIcon: slots.endIcon
+    },
+    slotProps: {
+      collapseIcon: slotProps.collapseIcon,
+      expandIcon: slotProps.expandIcon,
+      endIcon: slotProps.endIcon
+    }
+  }), [classes, slots.collapseIcon, slots.expandIcon, slots.endIcon, slotProps.collapseIcon, slotProps.expandIcon, slotProps.endIcon]);
   return /*#__PURE__*/_jsx(TreeViewContext.Provider, {
     value: contextValue,
     children: /*#__PURE__*/_jsx(TreeViewStyleContext.Provider, {

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

@@ -1,11 +1,10 @@
 import * as React from 'react';
-import { MergeSignaturesProperty, TreeItemWrapper, TreeRootWrapper, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginResponse, TreeViewPublicAPI } from "../models/index.js";
+import { TreeItemWrapper, TreeRootWrapper, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginResponse, TreeViewPublicAPI } from "../models/index.js";
 import { TreeViewStore } from "../utils/TreeViewStore.js";
-import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
 import type { TreeItemProps } from '../../TreeItem/TreeItem.types';
-import { TreeViewClasses } from "./TreeViewStyleContext.js";
+import { TreeViewClasses, TreeViewSlotProps, TreeViewSlots } from "./TreeViewStyleContext.js";
 export type TreeViewItemPluginsRunner = (props: TreeItemProps) => Required<TreeViewItemPluginResponse>;
-export type TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'contextValue'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'contextValue'>> & {
+export interface TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> {
   instance: TreeViewInstance<TSignatures, TOptionalSignatures>;
   publicAPI: TreeViewPublicAPI<TSignatures, TOptionalSignatures>;
   store: TreeViewStore<TSignatures>;
@@ -13,9 +12,11 @@ export type TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginS
   wrapItem: TreeItemWrapper<TSignatures>;
   wrapRoot: TreeRootWrapper;
   runItemPlugins: TreeViewItemPluginsRunner;
-};
+}
 export interface TreeViewProviderProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
   contextValue: TreeViewContextValue<TSignatures>;
   children: React.ReactNode;
   classes: Partial<TreeViewClasses> | undefined;
+  slots: TreeViewSlots | undefined;
+  slotProps: TreeViewSlotProps | undefined;
 }

package/esm/internals/TreeViewProvider/TreeViewStyleContext.d.ts

@@ -1,3 +1,4 @@
+import { SlotComponentProps } from '@mui/utils/types';
 import * as React from 'react';
 export interface TreeViewClasses {
   /** Styles applied to the root element. */
@@ -23,8 +24,30 @@ export interface TreeViewClasses {
   /** Styles applied to the item's loading icon element */
   itemLoadingIcon: string;
 }
+export interface TreeViewSlots {
+  /**
+   * The default icon used to collapse the item.
+   */
+  collapseIcon?: React.ElementType;
+  /**
+   * The default icon used to expand the item.
+   */
+  expandIcon?: React.ElementType;
+  /**
+   * The default icon displayed next to an end item.
+   * This is applied to all Tree Items and can be overridden by the TreeItem `icon` slot prop.
+   */
+  endIcon?: React.ElementType;
+}
+export interface TreeViewSlotProps {
+  collapseIcon?: SlotComponentProps<'svg', {}, {}>;
+  expandIcon?: SlotComponentProps<'svg', {}, {}>;
+  endIcon?: SlotComponentProps<'svg', {}, {}>;
+}
 export interface TreeViewStyleContextValue {
   classes: Partial<TreeViewClasses>;
+  slots: TreeViewSlots;
+  slotProps: TreeViewSlotProps;
 }
 /**
  * @ignore - internal component.

package/esm/internals/TreeViewProvider/TreeViewStyleContext.js

@@ -3,7 +3,9 @@ import * as React from 'react';
  * @ignore - internal component.
  */
 export const TreeViewStyleContext = /*#__PURE__*/React.createContext({
-  classes: {}
+  classes: {},
+  slots: {},
+  slotProps: {}
 });
 if (process.env.NODE_ENV !== 'production') {
   TreeViewStyleContext.displayName = 'TreeViewStyleContext';

package/esm/internals/hooks/useSelector.js

@@ -1,7 +1,4 @@
-// use-sync-external-store has no exports field defined
-// See https://github.com/facebook/react/issues/30698
-// eslint-disable-next-line import/extensions
-import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector.js';
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector';
 const defaultCompare = Object.is;
 export const useSelector = (store, selector, args = undefined, equals = defaultCompare) => {
   const selectorWithArgs = state => selector(state, args);

package/esm/internals/index.d.ts

@@ -14,12 +14,11 @@ export { useTreeViewFocus } from "./plugins/useTreeViewFocus/index.js";
 export type { UseTreeViewFocusSignature, UseTreeViewFocusParameters } from './plugins/useTreeViewFocus';
 export { useTreeViewKeyboardNavigation } from "./plugins/useTreeViewKeyboardNavigation/index.js";
 export type { UseTreeViewKeyboardNavigationSignature } from './plugins/useTreeViewKeyboardNavigation';
-export { useTreeViewIcons } from "./plugins/useTreeViewIcons/index.js";
-export type { UseTreeViewIconsSignature, UseTreeViewIconsParameters } from './plugins/useTreeViewIcons';
 export { useTreeViewItems, buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from "./plugins/useTreeViewItems/index.js";
 export { selectorItemMetaLookup, selectorItemMeta, selectorItemIndex, selectorItemOrderedChildrenIds } from "./plugins/useTreeViewItems/useTreeViewItems.selectors.js";
 export type { UseTreeViewItemsSignature, UseTreeViewItemsParameters, UseTreeViewItemsState } from './plugins/useTreeViewItems';
 export { useTreeViewLabel } from "./plugins/useTreeViewLabel/index.js";
+export { selectorIsItemBeingEdited, selectorIsAnyItemBeingEdited as selectorIsAnItemEdited } from "./plugins/useTreeViewLabel/useTreeViewLabel.selectors.js";
 export type { UseTreeViewLabelSignature, UseTreeViewLabelParameters } from './plugins/useTreeViewLabel';
 export { selectorIsItemExpanded } from "./plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
 export { selectorIsItemSelected } from "./plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";
@@ -31,4 +30,4 @@ export type { UseTreeViewJSXItemsSignature, UseTreeViewJSXItemsParameters } from
 export { createSelector } from "./utils/selectors.js";
 export { isTargetInDescendants } from "./utils/tree.js";
 export { TreeViewStore } from "./utils/TreeViewStore.js";
-export type { TreeViewClasses } from './TreeViewProvider/TreeViewStyleContext';
+export type { TreeViewClasses, TreeViewSlots, TreeViewSlotProps } from './TreeViewProvider/TreeViewStyleContext';

package/esm/internals/index.js

@@ -11,10 +11,10 @@ export { useTreeViewExpansion } from "./plugins/useTreeViewExpansion/index.js";
 export { useTreeViewSelection } from "./plugins/useTreeViewSelection/index.js";
 export { useTreeViewFocus } from "./plugins/useTreeViewFocus/index.js";
 export { useTreeViewKeyboardNavigation } from "./plugins/useTreeViewKeyboardNavigation/index.js";
-export { useTreeViewIcons } from "./plugins/useTreeViewIcons/index.js";
 export { useTreeViewItems, buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from "./plugins/useTreeViewItems/index.js";
 export { selectorItemMetaLookup, selectorItemMeta, selectorItemIndex, selectorItemOrderedChildrenIds } from "./plugins/useTreeViewItems/useTreeViewItems.selectors.js";
 export { useTreeViewLabel } from "./plugins/useTreeViewLabel/index.js";
+export { selectorIsItemBeingEdited, selectorIsAnyItemBeingEdited as selectorIsAnItemEdited } from "./plugins/useTreeViewLabel/useTreeViewLabel.selectors.js";
 export { selectorIsItemExpanded } from "./plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
 export { selectorIsItemSelected } from "./plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";
 export { selectorDataSourceState, selectorGetTreeItemError } from "./plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.selectors.js";

package/esm/internals/models/events.d.ts

@@ -1,9 +1,5 @@
-import * as React from 'react';
+import { MuiEvent } from '@mui/x-internals/types';
 export interface TreeViewEventLookupElement {
   params: object;
 }
-export type TreeViewEventListener<E extends TreeViewEventLookupElement> = (params: E['params'], event: MuiEvent<{}>) => void;
-export type MuiBaseEvent = React.SyntheticEvent<HTMLElement> | DocumentEventMap[keyof DocumentEventMap] | {};
-export type MuiEvent<E extends MuiBaseEvent = MuiBaseEvent> = E & {
-  defaultMuiPrevented?: boolean;
-};
+export type TreeViewEventListener<E extends TreeViewEventLookupElement> = (params: E['params'], event: MuiEvent<{}>) => void;

package/esm/internals/models/plugin.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { EventHandlers } from '@mui/utils/types';
-import { TreeViewExperimentalFeatures, TreeViewInstance, TreeViewModel } from "./treeView.js";
+import { TreeViewExperimentalFeatures, TreeViewInstance } from "./treeView.js";
 import type { MergeSignaturesProperty, OptionalIfEmpty } from './helpers';
 import { TreeViewEventLookupElement } from "./events.js";
 import type { TreeViewCorePluginSignatures } from '../corePlugins';
@@ -8,22 +8,31 @@ import { TreeViewItemPlugin } from "./itemPlugin.js";
 import { TreeViewItemId } from "../../models/index.js";
 import { TreeViewStore } from "../utils/TreeViewStore.js";
 export interface TreeViewPluginOptions<TSignature extends TreeViewAnyPluginSignature> {
+  /**
+   * An imperative API available for internal use. Used to access methods from other plugins.
+   */
   instance: TreeViewUsedInstance<TSignature>;
+  /**
+   * The Tree View parameters after being processed with the default values.
+   */
   params: TreeViewUsedDefaultizedParams<TSignature>;
-  slots: TSignature['slots'];
-  slotProps: TSignature['slotProps'];
   experimentalFeatures: TreeViewUsedExperimentalFeatures<TSignature>;
-  models: TreeViewUsedModels<TSignature>;
+  /**
+   * The store that can be used to access the state of other plugins.
+   */
   store: TreeViewUsedStore<TSignature>;
+  /**
+   * Reference to the root element.
+   */
   rootRef: React.RefObject<HTMLUListElement | null>;
+  /**
+   * All the plugins that are used in the tree-view.
+   */
   plugins: TreeViewPlugin<TreeViewAnyPluginSignature>[];
 }
-type TreeViewModelsInitializer<TSignature extends TreeViewAnyPluginSignature> = { [TControlled in keyof TSignature['models']]: {
-  getDefaultValue: (params: TSignature['defaultizedParams']) => Exclude<TSignature['defaultizedParams'][TControlled], undefined>;
-} };
 type TreeViewResponse<TSignature extends TreeViewAnyPluginSignature> = {
   getRootProps?: <TOther extends EventHandlers = {}>(otherHandlers: TOther) => React.HTMLAttributes<HTMLUListElement>;
-} & OptionalIfEmpty<'publicAPI', TSignature['publicAPI']> & OptionalIfEmpty<'instance', TSignature['instance']> & OptionalIfEmpty<'contextValue', TSignature['contextValue']>;
+} & OptionalIfEmpty<'publicAPI', TSignature['publicAPI']> & OptionalIfEmpty<'instance', TSignature['instance']>;
 export type TreeViewPluginSignature<T extends {
   params?: {};
   defaultizedParams?: {};
@@ -31,61 +40,61 @@ export type TreeViewPluginSignature<T extends {
   publicAPI?: {};
   events?: { [key in keyof T['events']]: TreeViewEventLookupElement };
   state?: {};
-  cache?: {};
-  contextValue?: {};
-  slots?: { [key in keyof T['slots']]: React.ElementType };
-  slotProps?: { [key in keyof T['slotProps']]: {} | (() => {}) };
-  modelNames?: keyof T['defaultizedParams'];
   experimentalFeatures?: string;
   dependencies?: readonly TreeViewAnyPluginSignature[];
   optionalDependencies?: readonly TreeViewAnyPluginSignature[];
 }> = {
+  /**
+   * The raw properties that can be passed to the plugin.
+   */
   params: T extends {
     params: {};
   } ? T['params'] : {};
+  /**
+   * The params after being processed with the default values.
+   */
   defaultizedParams: T extends {
     defaultizedParams: {};
   } ? T['defaultizedParams'] : {};
+  /**
+   * An imperative api available for internal use.
+   */
   instance: T extends {
     instance: {};
   } ? T['instance'] : {};
+  /**
+   * The public imperative API that will be exposed to the user.
+   * Accessed through the `apiRef` property of the plugin.
+   */
   publicAPI: T extends {
     publicAPI: {};
   } ? T['publicAPI'] : {};
   events: T extends {
     events: {};
   } ? T['events'] : {};
+  /**
+   * The state is the mutable data that will actually be stored in the plugin state and can be accessed by other plugins.
+   */
   state: T extends {
     state: {};
   } ? T['state'] : {};
-  cache: T extends {
-    cache: {};
-  } ? T['cache'] : {};
-  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>> } : {};
   experimentalFeatures: T extends {
     experimentalFeatures: string;
   } ? { [key in T['experimentalFeatures']]?: boolean } : {};
+  /**
+   * Any plugins that this plugin depends on.
+   */
   dependencies: T extends {
     dependencies: Array<any>;
   } ? T['dependencies'] : [];
+  /**
+   * Same as dependencies but the plugin might not have been initialized. Used for dependencies on plugins of features that can be enabled conditionally.
+   */
   optionalDependencies: T extends {
     optionalDependencies: Array<any>;
   } ? T['optionalDependencies'] : [];
 };
 export type TreeViewAnyPluginSignature = {
-  cache: any;
   state: any;
   instance: any;
   params: any;
@@ -93,10 +102,6 @@ export type TreeViewAnyPluginSignature = {
   dependencies: any;
   optionalDependencies: any;
   events: any;
-  contextValue: any;
-  slots: any;
-  slotProps: any;
-  models: any;
   experimentalFeatures: any;
   publicAPI: any;
 };
@@ -112,8 +117,6 @@ export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature>
 };
 export type TreeViewUsedStore<TSignature extends TreeViewAnyPluginSignature> = TreeViewStore<[TSignature, ...TSignature['dependencies']]>;
 type TreeViewUsedExperimentalFeatures<TSignature extends TreeViewAnyPluginSignature> = TreeViewExperimentalFeatures<[TSignature, ...TSignature['dependencies']], TSignature['optionalDependencies']>;
-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<MergeSignaturesProperty<TreeViewRequiredPlugins<TSignature>, 'models'>>;
 export type TreeViewUsedEvents<TSignature extends TreeViewAnyPluginSignature> = TSignature['events'] & MergeSignaturesProperty<TreeViewRequiredPlugins<TSignature>, 'events'>;
 export type TreeItemWrapper<TSignatures extends readonly TreeViewAnyPluginSignature[]> = (params: {
   itemId: TreeViewItemId;
@@ -125,14 +128,36 @@ export type TreeRootWrapper = (params: {
   children: React.ReactNode;
 }) => React.ReactNode;
 export type TreeViewPlugin<TSignature extends TreeViewAnyPluginSignature> = {
+  /**
+   * The main function of the plugin that will be executed by the Tree View.
+   *
+   * This should be a valid React `use` function, as it will be executed in the render phase and can contain hooks.
+   */
   (options: TreeViewPluginOptions<TSignature>): TreeViewResponse<TSignature>;
+  /**
+   * A function that receives the parameters and returns them after being processed with the default values.
+   *
+   * @param {TreeViewUsedParams<TSignature>} options The options object.
+   * @param {TreeViewUsedParams<TSignature>['params']} options.params The parameters before being processed with the default values.
+   * @param {TreeViewUsedExperimentalFeatures<TSignature>} options.experimentalFeatures An object containing the experimental feature flags.
+   * @returns {TSignature['defaultizedParams']} The parameters after being processed with the default values.
+   */
   getDefaultizedParams?: (options: {
     params: TreeViewUsedParams<TSignature>;
     experimentalFeatures: TreeViewUsedExperimentalFeatures<TSignature>;
   }) => TSignature['defaultizedParams'];
+  /**
+   * The initial state is computed after the default values are applied.
+   * It sets up the state for the first render.
+   * Other state modifications have to be done in effects and so could not be applied on the initial render.
+   *
+   * @param {TreeViewUsedDefaultizedParams<TSignature>} params The parameters after being processed with the default values.
+   * @returns {TSignature['state']} The initial state of the plugin.
+   */
   getInitialState?: (params: TreeViewUsedDefaultizedParams<TSignature>) => TSignature['state'];
-  getInitialCache?: () => TSignature['cache'];
-  models?: TreeViewModelsInitializer<TSignature>;
+  /**
+   * An object where each property used by the plugin is set to `true`.
+   */
   params: Record<keyof TSignature['params'], true>;
   itemPlugin?: TreeViewItemPlugin;
   /**

package/esm/internals/models/treeView.d.ts

@@ -16,11 +16,6 @@ export interface TreeViewItemMeta {
    */
   label?: string;
 }
-export interface TreeViewModel<TValue> {
-  name: string;
-  value: TValue;
-  setControlledValue: (value: TValue | ((prevValue: TValue) => TValue)) => void;
-}
 export type TreeViewInstance<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'instance'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
 export type TreeViewPublicAPI<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'publicAPI'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
 export type TreeViewExperimentalFeatures<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TSignatures, ...TOptionalSignatures], 'experimentalFeatures'>;