@mui/x-tree-view 8.22.0 → 8.24.0

package/internals/MinimalTreeViewStore/MinimalTreeViewStore.utils.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMinimalInitialState = createMinimalInitialState;
+exports.createTreeViewDefaultId = void 0;
+exports.deriveStateFromParameters = deriveStateFromParameters;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _empty = require("@base-ui/utils/empty");
+var _utils = require("../plugins/expansion/utils");
+var _items = require("../plugins/items");
+/**
+ * Returns the properties of the state that are derived from the parameters.
+ * This do not contain state properties that don't update whenever the parameters update.
+ */
+function deriveStateFromParameters(parameters) {
+  return {
+    disabledItemsFocusable: parameters.disabledItemsFocusable ?? false,
+    domStructure: 'nested',
+    itemChildrenIndentation: parameters.itemChildrenIndentation ?? '12px',
+    providedTreeId: parameters.id,
+    // TODO: Fix
+    expansionTrigger: (0, _utils.getExpansionTrigger)({
+      isItemEditable: parameters.isItemEditable,
+      expansionTrigger: parameters.expansionTrigger
+    }),
+    disableSelection: parameters.disableSelection ?? false,
+    multiSelect: parameters.multiSelect ?? false,
+    checkboxSelection: parameters.checkboxSelection ?? false,
+    selectionPropagation: parameters.selectionPropagation ?? _empty.EMPTY_OBJECT
+  };
+}
+function applyModelInitialValue(controlledValue, defaultValue, fallback) {
+  if (controlledValue !== undefined) {
+    return controlledValue;
+  }
+  if (defaultValue !== undefined) {
+    return defaultValue;
+  }
+  return fallback;
+}
+function createMinimalInitialState(parameters) {
+  return (0, _extends2.default)({
+    treeId: undefined,
+    focusedItemId: null
+  }, deriveStateFromParameters(parameters), _items.TreeViewItemsPlugin.buildItemsStateIfNeeded(parameters), {
+    expandedItems: applyModelInitialValue(parameters.expandedItems, parameters.defaultExpandedItems, []),
+    selectedItems: applyModelInitialValue(parameters.selectedItems, parameters.defaultSelectedItems, parameters.multiSelect ? _empty.EMPTY_ARRAY : null)
+  });
+}
+let globalTreeViewDefaultId = 0;
+const createTreeViewDefaultId = () => {
+  globalTreeViewDefaultId += 1;
+  return `mui-tree-view-${globalTreeViewDefaultId}`;
+};
+exports.createTreeViewDefaultId = createTreeViewDefaultId;

package/internals/MinimalTreeViewStore/TimeoutManager.d.ts

@@ -0,0 +1,9 @@
+export declare class TimeoutManager {
+  private timeoutIds;
+  private intervalIds;
+  startTimeout: (key: string, delay: number, fn: Function) => void;
+  startInterval: (key: string, delay: number, fn: Function) => void;
+  clearTimeout: (key: string) => void;
+  clearInterval: (key: string) => void;
+  clearAll: () => void;
+}

package/internals/MinimalTreeViewStore/TimeoutManager.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TimeoutManager = void 0;
+class TimeoutManager {
+  timeoutIds = new Map();
+  intervalIds = new Map();
+  startTimeout = (key, delay, fn) => {
+    this.clearTimeout(key);
+    const id = setTimeout(() => {
+      this.timeoutIds.delete(key);
+      fn();
+    }, delay); /* Node.js types are enabled in development */
+
+    this.timeoutIds.set(key, id);
+  };
+  startInterval = (key, delay, fn) => {
+    this.clearTimeout(key);
+    const id = setInterval(fn, delay); /* Node.js types are enabled in development */
+
+    this.intervalIds.set(key, id);
+  };
+  clearTimeout = key => {
+    const id = this.timeoutIds.get(key);
+    if (id != null) {
+      clearTimeout(id);
+      this.timeoutIds.delete(key);
+    }
+  };
+  clearInterval = key => {
+    const id = this.intervalIds.get(key);
+    if (id != null) {
+      clearInterval(id);
+      this.intervalIds.delete(key);
+    }
+  };
+  clearAll = () => {
+    this.timeoutIds.forEach(clearTimeout);
+    this.timeoutIds.clear();
+    this.intervalIds.forEach(clearInterval);
+    this.intervalIds.clear();
+  };
+}
+exports.TimeoutManager = TimeoutManager;

package/internals/MinimalTreeViewStore/TreeViewItemPluginManager.d.ts

@@ -0,0 +1,12 @@
+import { TreeItemWrapper, TreeViewAnyStore, TreeViewItemPlugin } from "../models/index.js";
+/**
+ * Manages the registration and application of plugins for the Tree Item.
+ * This will be replaced with a proper implementation in the future.
+ */
+export declare class TreeViewItemPluginManager<TStore extends TreeViewAnyStore> {
+  private itemPlugins;
+  private itemWrappers;
+  register: (plugin: TreeViewItemPlugin, wrapItem: TreeItemWrapper<TStore> | null) => void;
+  listPlugins: () => TreeViewItemPlugin[];
+  listWrappers: () => TreeItemWrapper<TStore>[];
+}

package/internals/MinimalTreeViewStore/TreeViewItemPluginManager.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TreeViewItemPluginManager = void 0;
+/**
+ * Manages the registration and application of plugins for the Tree Item.
+ * This will be replaced with a proper implementation in the future.
+ */
+class TreeViewItemPluginManager {
+  itemPlugins = [];
+  itemWrappers = [];
+  register = (plugin, wrapItem) => {
+    this.itemPlugins.push(plugin);
+    if (wrapItem) {
+      this.itemWrappers.push(wrapItem);
+    }
+  };
+  listPlugins = () => this.itemPlugins;
+  listWrappers = () => this.itemWrappers;
+}
+exports.TreeViewItemPluginManager = TreeViewItemPluginManager;

package/internals/MinimalTreeViewStore/index.d.ts

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

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