@mui/x-tree-view 8.23.0 → 8.24.0

package/internals/MinimalTreeViewStore/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _MinimalTreeViewStore = require("./MinimalTreeViewStore");
+Object.keys(_MinimalTreeViewStore).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _MinimalTreeViewStore[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _MinimalTreeViewStore[key];
+    }
+  });
+});
+var _MinimalTreeViewStore2 = require("./MinimalTreeViewStore.types");
+Object.keys(_MinimalTreeViewStore2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _MinimalTreeViewStore2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _MinimalTreeViewStore2[key];
+    }
+  });
+});

package/internals/RichTreeViewStore/RichTreeViewStore.d.ts

@@ -0,0 +1,53 @@
+import { TreeViewValidItem } from "../../models/index.js";
+import { TreeViewLabelEditingPlugin } from "../plugins/labelEditing/index.js";
+import { MinimalTreeViewStore } from "../MinimalTreeViewStore/index.js";
+import { RichTreeViewStoreParameters, RichTreeViewState } from "./RichTreeViewStore.types.js";
+export declare class ExtendableRichTreeViewStore<R extends TreeViewValidItem<R>, Multiple extends boolean | undefined, State extends RichTreeViewState<R, Multiple> = RichTreeViewState<R, Multiple>, Parameters extends RichTreeViewStoreParameters<R, Multiple> = RichTreeViewStoreParameters<R, Multiple>> extends MinimalTreeViewStore<R, Multiple, State, Parameters> {
+  labelEditing: TreeViewLabelEditingPlugin;
+  /**
+   * Mapper of the RichTreeViewStore.
+   * Can be used by classes extending the RichTreeViewStore to create their own mapper.
+   */
+  static rawMapper: import("../index.js").TreeViewParametersToStateMapper<any, any, RichTreeViewState<any, any>, RichTreeViewStoreParameters<any, any>>;
+  buildPublicAPI(): {
+    setEditedItem: (itemId: import("../../index.js").TreeViewItemId | null) => void;
+    updateItemLabel: (itemId: import("../../index.js").TreeViewItemId, label: string) => void;
+    setItemSelection: ({
+      itemId,
+      event,
+      keepExistingSelection,
+      shouldBeSelected
+    }: {
+      itemId: string;
+      event?: React.SyntheticEvent | null;
+      shouldBeSelected?: boolean;
+      keepExistingSelection?: boolean;
+    }) => void;
+    isItemExpanded: (itemId: import("../../index.js").TreeViewItemId) => boolean;
+    setItemExpansion: ({
+      itemId,
+      event,
+      shouldBeExpanded
+    }: {
+      itemId: import("../../index.js").TreeViewItemId;
+      event?: React.SyntheticEvent | null;
+      shouldBeExpanded?: boolean;
+    }) => void;
+    focusItem: (event: React.SyntheticEvent | null, itemId: import("../../index.js").TreeViewItemId) => void;
+    getItem: (itemId: import("../../index.js").TreeViewItemId) => R;
+    getItemDOMElement: (itemId: import("../../index.js").TreeViewItemId) => HTMLElement | null;
+    getItemOrderedChildrenIds: (itemId: import("../../index.js").TreeViewItemId | null) => import("../../index.js").TreeViewItemId[];
+    getItemTree: () => R[];
+    getParentId: (itemId: import("../../index.js").TreeViewItemId) => import("../../index.js").TreeViewItemId | null;
+    setIsItemDisabled: ({
+      itemId,
+      shouldBeDisabled
+    }: {
+      itemId: import("../../index.js").TreeViewItemId;
+      shouldBeDisabled?: boolean;
+    }) => void;
+  };
+}
+export declare class RichTreeViewStore<R extends TreeViewValidItem<R>, Multiple extends boolean | undefined> extends ExtendableRichTreeViewStore<R, Multiple, RichTreeViewState<R, Multiple>, RichTreeViewStoreParameters<R, Multiple>> {
+  constructor(parameters: RichTreeViewStoreParameters<R, Multiple>);
+}

package/internals/RichTreeViewStore/RichTreeViewStore.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RichTreeViewStore = exports.ExtendableRichTreeViewStore = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _labelEditing = require("../plugins/labelEditing");
+var _MinimalTreeViewStore = require("../MinimalTreeViewStore");
+var _RichTreeViewStore = require("./RichTreeViewStore.utils");
+class ExtendableRichTreeViewStore extends _MinimalTreeViewStore.MinimalTreeViewStore {
+  labelEditing = new _labelEditing.TreeViewLabelEditingPlugin(this);
+
+  /**
+   * Mapper of the RichTreeViewStore.
+   * Can be used by classes extending the RichTreeViewStore to create their own mapper.
+   */
+  static rawMapper = _RichTreeViewStore.parametersToStateMapper;
+  buildPublicAPI() {
+    return (0, _extends2.default)({}, super.buildPublicAPI(), this.labelEditing.buildPublicAPI());
+  }
+}
+exports.ExtendableRichTreeViewStore = ExtendableRichTreeViewStore;
+class RichTreeViewStore extends ExtendableRichTreeViewStore {
+  constructor(parameters) {
+    super(parameters, 'RichTreeView', _RichTreeViewStore.parametersToStateMapper);
+  }
+}
+exports.RichTreeViewStore = RichTreeViewStore;

package/internals/RichTreeViewStore/RichTreeViewStore.types.d.ts

@@ -0,0 +1,34 @@
+import { TreeViewItemId, TreeViewValidItem } from "../../models/index.js";
+import { MinimalTreeViewParameters, MinimalTreeViewState } from "../MinimalTreeViewStore/index.js";
+import { RichTreeViewLazyLoadedItemsStatus } from "../plugins/lazyLoading/index.js";
+export interface RichTreeViewState<R extends TreeViewValidItem<R>, Multiple extends boolean | undefined> extends MinimalTreeViewState<R, Multiple> {
+  /**
+   * Determine if a given item can be edited.
+   */
+  isItemEditable: ((item: any) => boolean) | boolean;
+  /**
+   * The id of the item currently being edited.
+   */
+  editedItemId: string | null;
+  /**
+   * The status of the items loaded using lazy loading.
+   * Is null if lazy loading is not enabled.
+   */
+  lazyLoadedItems: RichTreeViewLazyLoadedItemsStatus | null;
+}
+export interface RichTreeViewStoreParameters<R extends TreeViewValidItem<R>, Multiple extends boolean | undefined> extends MinimalTreeViewParameters<R, Multiple> {
+  /**
+   * Callback fired when the label of an item changes.
+   * @param {TreeViewItemId} itemId The id of the item that was edited.
+   * @param {string} newLabel The new label of the items.
+   */
+  onItemLabelChange?: (itemId: TreeViewItemId, newLabel: string) => void;
+  /**
+   * Determine if a given item can be edited.
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {boolean} `true` if the item can be edited.
+   * @default () => false
+   */
+  isItemEditable?: boolean | ((item: R) => boolean);
+}

package/internals/RichTreeViewStore/RichTreeViewStore.utils.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewParametersToStateMapper } from "../MinimalTreeViewStore/index.js";
+import { RichTreeViewStoreParameters, RichTreeViewState } from "./RichTreeViewStore.types.js";
+export declare const parametersToStateMapper: TreeViewParametersToStateMapper<any, any, RichTreeViewState<any, any>, RichTreeViewStoreParameters<any, any>>;

package/internals/RichTreeViewStore/RichTreeViewStore.utils.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parametersToStateMapper = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+const deriveStateFromParameters = parameters => ({
+  isItemEditable: parameters.isItemEditable ?? false
+});
+const parametersToStateMapper = exports.parametersToStateMapper = {
+  getInitialState: (minimalInitialState, parameters) => (0, _extends2.default)({}, minimalInitialState, deriveStateFromParameters(parameters), {
+    editedItemId: null,
+    lazyLoadedItems: null
+  }),
+  updateStateFromParameters: (newMinimalState, parameters) => {
+    const newState = (0, _extends2.default)({}, newMinimalState, deriveStateFromParameters(parameters));
+    return newState;
+  },
+  shouldIgnoreItemsStateUpdate: () => false
+};

package/internals/RichTreeViewStore/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./RichTreeViewStore.js";
+export * from "./RichTreeViewStore.types.js";
+export * from "./RichTreeViewStore.utils.js";

package/internals/RichTreeViewStore/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _RichTreeViewStore = require("./RichTreeViewStore");
+Object.keys(_RichTreeViewStore).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _RichTreeViewStore[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _RichTreeViewStore[key];
+    }
+  });
+});
+var _RichTreeViewStore2 = require("./RichTreeViewStore.types");
+Object.keys(_RichTreeViewStore2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _RichTreeViewStore2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _RichTreeViewStore2[key];
+    }
+  });
+});
+var _RichTreeViewStore3 = require("./RichTreeViewStore.utils");
+Object.keys(_RichTreeViewStore3).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _RichTreeViewStore3[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _RichTreeViewStore3[key];
+    }
+  });
+});

package/internals/SimpleTreeViewStore/SimpleTreeViewStore.d.ts

@@ -0,0 +1,8 @@
+import { MinimalTreeViewStore } from "../MinimalTreeViewStore/index.js";
+import { InnerSimpleTreeViewParameters, SimpleTreeViewItem, SimpleTreeViewStoreParameters, SimpleTreeViewState } from "./SimpleTreeViewStore.types.js";
+import { TreeViewJSXItemsPlugin } from "../plugins/jsxItems/index.js";
+export declare class SimpleTreeViewStore<Multiple extends boolean | undefined> extends MinimalTreeViewStore<SimpleTreeViewItem, Multiple, SimpleTreeViewState<Multiple>, InnerSimpleTreeViewParameters<Multiple>> {
+  jsxItems: TreeViewJSXItemsPlugin;
+  constructor(parameters: SimpleTreeViewStoreParameters<Multiple>);
+  updateStateFromParameters(parameters: SimpleTreeViewStoreParameters<Multiple>): void;
+}

package/internals/SimpleTreeViewStore/SimpleTreeViewStore.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SimpleTreeViewStore = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _empty = require("@base-ui/utils/empty");
+var _MinimalTreeViewStore = require("../MinimalTreeViewStore");
+var _jsxItems = require("../plugins/jsxItems");
+var _SimpleTreeViewStore = require("./SimpleTreeViewStore.utils");
+class SimpleTreeViewStore extends _MinimalTreeViewStore.MinimalTreeViewStore {
+  jsxItems = new _jsxItems.TreeViewJSXItemsPlugin(this);
+  constructor(parameters) {
+    super((0, _extends2.default)({}, parameters, {
+      items: _empty.EMPTY_ARRAY
+    }), 'SimpleTreeView', _SimpleTreeViewStore.parametersToStateMapper);
+  }
+  updateStateFromParameters(parameters) {
+    super.updateStateFromParameters((0, _extends2.default)({}, parameters, {
+      items: _empty.EMPTY_ARRAY
+    }));
+  }
+}
+exports.SimpleTreeViewStore = SimpleTreeViewStore;

package/internals/SimpleTreeViewStore/SimpleTreeViewStore.types.d.ts

@@ -0,0 +1,9 @@
+import { MinimalTreeViewParameters, MinimalTreeViewState } from "../MinimalTreeViewStore/index.js";
+export interface SimpleTreeViewState<Multiple extends boolean | undefined> extends MinimalTreeViewState<SimpleTreeViewItem, Multiple> {}
+export interface InnerSimpleTreeViewParameters<Multiple extends boolean | undefined> extends MinimalTreeViewParameters<SimpleTreeViewItem, Multiple> {}
+export interface SimpleTreeViewStoreParameters<Multiple extends boolean | undefined> extends Omit<InnerSimpleTreeViewParameters<Multiple>, 'items' | 'isItemDisabled' | 'isItemSelectionDisabled' | 'getItemLabel' | 'getItemChildren' | 'getItemId'> {}
+export interface SimpleTreeViewItem {
+  id: string;
+  label: string;
+  children?: SimpleTreeViewItem[];
+}

package/internals/SimpleTreeViewStore/SimpleTreeViewStore.utils.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewParametersToStateMapper } from "../MinimalTreeViewStore/index.js";
+import { InnerSimpleTreeViewParameters, SimpleTreeViewState } from "./SimpleTreeViewStore.types.js";
+export declare const parametersToStateMapper: TreeViewParametersToStateMapper<any, any, SimpleTreeViewState<any>, InnerSimpleTreeViewParameters<any>>;

package/internals/SimpleTreeViewStore/SimpleTreeViewStore.utils.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parametersToStateMapper = void 0;
+const parametersToStateMapper = exports.parametersToStateMapper = {
+  getInitialState: minimalInitialState => minimalInitialState,
+  updateStateFromParameters: newMinimalState => newMinimalState,
+  shouldIgnoreItemsStateUpdate: () => true
+};

package/internals/SimpleTreeViewStore/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./SimpleTreeViewStore.js";
+export * from "./SimpleTreeViewStore.types.js";

package/internals/SimpleTreeViewStore/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _SimpleTreeViewStore = require("./SimpleTreeViewStore");
+Object.keys(_SimpleTreeViewStore).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _SimpleTreeViewStore[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _SimpleTreeViewStore[key];
+    }
+  });
+});
+var _SimpleTreeViewStore2 = require("./SimpleTreeViewStore.types");
+Object.keys(_SimpleTreeViewStore2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _SimpleTreeViewStore2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _SimpleTreeViewStore2[key];
+    }
+  });
+});

package/internals/TreeViewItemDepthContext/TreeViewItemDepthContext.d.ts

@@ -1,5 +1,4 @@
 import * as React from 'react';
 import { TreeViewItemId } from "../../models/index.js";
-import { TreeViewState } from "../models/index.js";
-import type { UseTreeViewItemsSignature } from "../plugins/useTreeViewItems/index.js";
-export declare const TreeViewItemDepthContext: React.Context<number | ((state: TreeViewState<[UseTreeViewItemsSignature]>, itemId: TreeViewItemId) => number)>;
+import { MinimalTreeViewState } from "../MinimalTreeViewStore/index.js";
+export declare const TreeViewItemDepthContext: React.Context<number | ((state: MinimalTreeViewState<any, any>, itemId: TreeViewItemId) => number)>;

package/internals/TreeViewProvider/TreeViewChildrenItemProvider.js

@@ -12,7 +12,7 @@ var React = _interopRequireWildcard(require("react"));
 var _propTypes = _interopRequireDefault(require("prop-types"));
 var _TreeViewContext = require("./TreeViewContext");
 var _utils = require("../utils/utils");
-var _useTreeViewItems = require("../plugins/useTreeViewItems/useTreeViewItems.selectors");
+var _selectors = require("../plugins/items/selectors");
 var _jsxRuntime = require("react/jsx-runtime");
 const TreeViewChildrenItemContext = exports.TreeViewChildrenItemContext = /*#__PURE__*/React.createContext(null);
 if (process.env.NODE_ENV !== "production") TreeViewChildrenItemContext.displayName = "TreeViewChildrenItemContext";
@@ -23,7 +23,6 @@ function TreeViewChildrenItemProvider(props) {
     idAttribute
   } = props;
   const {
-    instance,
     store,
     rootRef
   } = (0, _TreeViewContext.useTreeViewContext)();
@@ -32,7 +31,7 @@ function TreeViewChildrenItemProvider(props) {
     if (!rootRef.current) {
       return;
     }
-    const previousChildrenIds = _useTreeViewItems.itemsSelectors.itemOrderedChildrenIds(store.state, itemId ?? null) ?? [];
+    const previousChildrenIds = _selectors.itemsSelectors.itemOrderedChildrenIds(store.state, itemId ?? null) ?? [];
     const escapedIdAttr = (0, _utils.escapeOperandAttributeSelector)(idAttribute ?? rootRef.current.id);
 
     // If collapsed, skip childrenIds update prevents clearing the parent's indeterminate state after opening a sibling.
@@ -46,7 +45,7 @@ function TreeViewChildrenItemProvider(props) {
     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) {
-      instance.setJSXItemsOrderedChildrenIds(itemId ?? null, childrenIds);
+      store.jsxItems.setJSXItemsOrderedChildrenIds(itemId ?? null, childrenIds);
     }
   });
   const value = React.useMemo(() => ({

package/internals/TreeViewProvider/TreeViewContext.d.ts

@@ -1,8 +1,8 @@
 import * as React from 'react';
-import { TreeViewAnyPluginSignature } from "../models/index.js";
+import { TreeViewAnyStore } from "../models/index.js";
 import { TreeViewContextValue } from "./TreeViewProvider.types.js";
 /**
  * @ignore - internal component.
  */
-export declare const TreeViewContext: React.Context<TreeViewContextValue<any, []> | null>;
-export declare const useTreeViewContext: <TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []>() => TreeViewContextValue<TSignatures, TOptionalSignatures>;
+export declare const TreeViewContext: React.Context<TreeViewContextValue<any> | null>;
+export declare const useTreeViewContext: <TStore extends TreeViewAnyStore>() => TreeViewContextValue<TStore>;

package/internals/TreeViewProvider/TreeViewProvider.d.ts

@@ -1,8 +1,8 @@
 import { TreeViewProviderProps } from "./TreeViewProvider.types.js";
-import { TreeViewAnyPluginSignature } from "../models/index.js";
+import { TreeViewAnyStore } from "../models/index.js";
 /**
  * Sets up the contexts for the underlying Tree Item components.
  *
  * @ignore - do not document.
  */
-export declare function TreeViewProvider<TSignatures extends readonly TreeViewAnyPluginSignature[]>(props: TreeViewProviderProps<TSignatures>): import("react/jsx-runtime").JSX.Element;
+export declare function TreeViewProvider<TStore extends TreeViewAnyStore>(props: TreeViewProviderProps<TStore>): import("react/jsx-runtime").JSX.Element;

package/internals/TreeViewProvider/TreeViewProvider.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.TreeViewProvider = TreeViewProvider;
 var React = _interopRequireWildcard(require("react"));
+var _empty = require("@base-ui/utils/empty");
 var _TreeViewContext = require("./TreeViewContext");
 var _TreeViewStyleContext = require("./TreeViewStyleContext");
+var _useTreeViewBuildContext = require("./useTreeViewBuildContext");
 var _jsxRuntime = require("react/jsx-runtime");
-const EMPTY_OBJECT = {};
-
 /**
  * Sets up the contexts for the underlying Tree Item components.
  *
@@ -18,12 +18,19 @@ const EMPTY_OBJECT = {};
  */
 function TreeViewProvider(props) {
   const {
-    contextValue,
-    classes = EMPTY_OBJECT,
-    slots = EMPTY_OBJECT,
-    slotProps = EMPTY_OBJECT,
+    store,
+    apiRef,
+    rootRef,
+    classes = _empty.EMPTY_OBJECT,
+    slots = _empty.EMPTY_OBJECT,
+    slotProps = _empty.EMPTY_OBJECT,
     children
   } = props;
+  const contextValue = (0, _useTreeViewBuildContext.useTreeViewBuildContext)({
+    store,
+    apiRef,
+    rootRef
+  });
   const styleContextValue = React.useMemo(() => ({
     classes,
     slots: {
@@ -41,9 +48,7 @@ function TreeViewProvider(props) {
     value: contextValue,
     children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_TreeViewStyleContext.TreeViewStyleContext.Provider, {
       value: styleContextValue,
-      children: contextValue.wrapRoot({
-        children
-      })
+      children: children
     })
   });
 }

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

@@ -1,20 +1,18 @@
 import * as React from 'react';
-import { TreeItemWrapper, TreeRootWrapper, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginResponse, TreeViewPublicAPI, TreeViewReadonlyStore } from "../models/index.js";
+import { TreeItemWrapper, TreeViewItemPluginResponse, TreeViewPublicAPI, TreeViewAnyStore } from "../models/index.js";
 import type { TreeItemProps } from "../../TreeItem/TreeItem.types.js";
 import { TreeViewClasses, TreeViewSlotProps, TreeViewSlots } from "./TreeViewStyleContext.js";
-import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
+import { UseTreeViewBuildContextParameters } from "./useTreeViewBuildContext.js";
 export type TreeViewItemPluginsRunner = (props: TreeItemProps) => Required<TreeViewItemPluginResponse>;
-export interface TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> {
-  instance: TreeViewInstance<TSignatures, TOptionalSignatures>;
-  publicAPI: TreeViewPublicAPI<TSignatures, TOptionalSignatures>;
-  store: TreeViewReadonlyStore<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>;
+export type TreeViewStoreInContext<TStore extends TreeViewAnyStore> = Omit<TStore, 'setState' | 'update' | 'set' | 'updateStateFromParameters' | 'disposeEffect' | 'registerStoreEffect' | 'itemPluginManager' | 'parameters'>;
+export interface TreeViewContextValue<TStore extends TreeViewAnyStore> {
+  publicAPI: TreeViewPublicAPI<TStore>;
+  store: TreeViewStoreInContext<TStore>;
   rootRef: React.RefObject<HTMLUListElement | null>;
-  wrapItem: TreeItemWrapper<TSignatures>;
-  wrapRoot: TreeRootWrapper;
+  wrapItem: TreeItemWrapper<TStore>;
   runItemPlugins: TreeViewItemPluginsRunner;
 }
-export interface TreeViewProviderProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
-  contextValue: TreeViewContextValue<TSignatures>;
+export interface TreeViewProviderProps<TStore extends TreeViewAnyStore> extends UseTreeViewBuildContextParameters<TStore> {
   children: React.ReactNode;
   classes: Partial<TreeViewClasses> | undefined;
   slots: TreeViewSlots | undefined;

package/internals/TreeViewProvider/index.d.ts

@@ -1,3 +1,3 @@
 export { TreeViewProvider } from "./TreeViewProvider.js";
 export { useTreeViewContext } from "./TreeViewContext.js";
-export type { TreeViewProviderProps, TreeViewContextValue, TreeViewItemPluginsRunner } from "./TreeViewProvider.types.js";
+export type { TreeViewProviderProps, TreeViewContextValue, TreeViewItemPluginsRunner, TreeViewStoreInContext } from "./TreeViewProvider.types.js";

package/internals/TreeViewProvider/useTreeViewBuildContext.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { TreeViewContextValue, TreeViewItemPluginsRunner, TreeViewStoreInContext } from "./TreeViewProvider.types.js";
+import { TreeViewAnyStore, TreeViewPublicAPI, TreeItemWrapper } from "../models/index.js";
+export declare const useTreeViewBuildContext: <TStore extends TreeViewAnyStore>(parameters: UseTreeViewBuildContextParameters<TStore>) => TreeViewContextValue<TStore>;
+export interface UseTreeViewBuildContextParameters<TStore extends TreeViewAnyStore> {
+  store: TStore;
+  rootRef: React.RefObject<HTMLUListElement | null>;
+  apiRef: React.RefObject<Partial<TreeViewPublicAPI<TStore>> | undefined> | undefined;
+}
+export interface UseTreeViewBuildContextReturnValue<TStore extends TreeViewAnyStore> {
+  publicAPI: TreeViewPublicAPI<TStore>;
+  store: TreeViewStoreInContext<TStore>;
+  rootRef: React.RefObject<HTMLUListElement | null>;
+  wrapItem: TreeItemWrapper<TStore>;
+  runItemPlugins: TreeViewItemPluginsRunner;
+}

package/internals/{useTreeView → TreeViewProvider}/useTreeViewBuildContext.js

@@ -6,24 +6,22 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useTreeViewBuildContext = void 0;
 var React = _interopRequireWildcard(require("react"));
+var _useRefWithInit = require("@base-ui/utils/useRefWithInit");
 const useTreeViewBuildContext = parameters => {
   const {
-    plugins,
-    instance,
-    publicAPI,
     store,
+    apiRef,
     rootRef
   } = parameters;
+  const publicAPI = (0, _useRefWithInit.useRefWithInit)(() => store.buildPublicAPI()).current;
+  initializeInputApiRef(publicAPI, apiRef);
   const runItemPlugins = React.useCallback(itemPluginProps => {
     let finalRootRef = null;
     let finalContentRef = null;
     const pluginPropEnhancers = [];
     const pluginPropEnhancersNames = {};
-    plugins.forEach(plugin => {
-      if (!plugin.itemPlugin) {
-        return;
-      }
-      const itemPluginResponse = plugin.itemPlugin({
+    store.itemPluginManager.listPlugins().forEach(itemPlugin => {
+      const itemPluginResponse = itemPlugin({
         props: itemPluginProps,
         rootRef: finalRootRef,
         contentRef: finalContentRef
@@ -59,50 +57,38 @@ const useTreeViewBuildContext = parameters => {
       rootRef: finalRootRef,
       propsEnhancers
     };
-  }, [plugins]);
+  }, [store]);
   const wrapItem = React.useCallback(({
     itemId,
     children,
     idAttribute
   }) => {
     let finalChildren = children;
+    const itemsWrapper = store.itemPluginManager.listWrappers();
+
     // The wrappers are reversed to ensure that the first wrapper is the outermost one.
-    for (let i = plugins.length - 1; i >= 0; i -= 1) {
-      const plugin = plugins[i];
-      if (plugin.wrapItem) {
-        finalChildren = plugin.wrapItem({
-          instance,
-          itemId,
-          children: finalChildren,
-          idAttribute
-        });
-      }
-    }
-    return finalChildren;
-  }, [plugins, instance]);
-  const wrapRoot = React.useCallback(({
-    children
-  }) => {
-    let finalChildren = children;
-    // The wrappers are reversed to ensure that the first wrapper is the outermost one.
-    for (let i = plugins.length - 1; i >= 0; i -= 1) {
-      const plugin = plugins[i];
-      if (plugin.wrapRoot) {
-        finalChildren = plugin.wrapRoot({
-          children: finalChildren
-        });
-      }
+    for (let i = itemsWrapper.length - 1; i >= 0; i -= 1) {
+      const itemWrapper = itemsWrapper[i];
+      finalChildren = itemWrapper({
+        store: store,
+        itemId,
+        children: finalChildren,
+        idAttribute
+      });
     }
     return finalChildren;
-  }, [plugins]);
+  }, [store]);
   return React.useMemo(() => ({
     runItemPlugins,
     wrapItem,
-    wrapRoot,
-    instance,
     publicAPI,
     store,
     rootRef
-  }), [runItemPlugins, wrapItem, wrapRoot, instance, publicAPI, store, rootRef]);
+  }), [runItemPlugins, wrapItem, publicAPI, store, rootRef]);
 };
-exports.useTreeViewBuildContext = useTreeViewBuildContext;
+exports.useTreeViewBuildContext = useTreeViewBuildContext;
+function initializeInputApiRef(publicAPI, apiRef) {
+  if (apiRef != null && apiRef.current == null) {
+    apiRef.current = publicAPI;
+  }
+}

package/internals/components/RichTreeViewItems.js

@@ -10,20 +10,20 @@ exports.RichTreeViewItems = RichTreeViewItems;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
 var React = _interopRequireWildcard(require("react"));
+var _empty = require("@base-ui/utils/empty");
 var _store = require("@mui/x-internals/store");
 var _useSlotProps2 = _interopRequireDefault(require("@mui/utils/useSlotProps"));
 var _fastObjectShallowCompare = require("@mui/x-internals/fastObjectShallowCompare");
 var _TreeItem = require("../../TreeItem");
-var _useTreeViewItems = require("../plugins/useTreeViewItems");
+var _items = require("../plugins/items");
 var _TreeViewProvider = require("../TreeViewProvider");
-var _useTreeViewExpansion = require("../plugins/useTreeViewExpansion");
+var _expansion = require("../plugins/expansion");
 var _jsxRuntime = require("react/jsx-runtime");
 const _excluded = ["ownerState"];
 const RichTreeViewItemsContext = /*#__PURE__*/React.createContext(null);
 if (process.env.NODE_ENV !== "production") RichTreeViewItemsContext.displayName = "RichTreeViewItemsContext";
-const EMPTY_ARRAY = [];
-const selectorNoChildren = () => EMPTY_ARRAY;
-const selectorChildrenIdsNull = state => _useTreeViewItems.itemsSelectors.itemOrderedChildrenIds(state, null);
+const selectorNoChildren = () => _empty.EMPTY_ARRAY;
+const selectorChildrenIdsNull = state => _items.itemsSelectors.itemOrderedChildrenIds(state, null);
 const WrappedTreeItem = /*#__PURE__*/React.memo(function WrappedTreeItem({
   itemSlot,
   itemSlotProps,
@@ -34,8 +34,8 @@ const WrappedTreeItem = /*#__PURE__*/React.memo(function WrappedTreeItem({
   const {
     store
   } = (0, _TreeViewProvider.useTreeViewContext)();
-  const itemMeta = (0, _store.useStore)(store, _useTreeViewItems.itemsSelectors.itemMeta, itemId);
-  const children = (0, _store.useStore)(store, skipChildren ? selectorNoChildren : _useTreeViewItems.itemsSelectors.itemOrderedChildrenIds, itemId);
+  const itemMeta = (0, _store.useStore)(store, _items.itemsSelectors.itemMeta, itemId);
+  const children = (0, _store.useStore)(store, skipChildren ? selectorNoChildren : _items.itemsSelectors.itemOrderedChildrenIds, itemId);
   const Item = itemSlot ?? _TreeItem.TreeItem;
   const _useSlotProps = (0, _useSlotProps2.default)({
       elementType: Item,
@@ -66,8 +66,8 @@ function RichTreeViewItems(props) {
   } = (0, _TreeViewProvider.useTreeViewContext)();
   const itemSlot = slots?.item;
   const itemSlotProps = slotProps?.item;
-  const domStructure = (0, _store.useStore)(store, _useTreeViewItems.itemsSelectors.domStructure);
-  const items = (0, _store.useStore)(store, domStructure === 'flat' ? _useTreeViewExpansion.expansionSelectors.flatList : selectorChildrenIdsNull);
+  const domStructure = (0, _store.useStore)(store, _items.itemsSelectors.domStructure);
+  const items = (0, _store.useStore)(store, domStructure === 'flat' ? _expansion.expansionSelectors.flatList : selectorChildrenIdsNull);
   const skipChildren = domStructure === 'flat';
   const renderItem = React.useCallback(itemId => {
     return /*#__PURE__*/(0, _jsxRuntime.jsx)(WrappedTreeItem, {