@mui/x-tree-view 8.23.0 → 8.24.0

package/esm/internals/plugins/id/selectors.d.ts

@@ -0,0 +1,13 @@
+import { MinimalTreeViewState } from "../../MinimalTreeViewStore/index.js";
+export declare const idSelectors: {
+  /**
+   * Get the id attribute of the tree view.
+   */
+  treeId: (state: MinimalTreeViewState<any, any>) => string | undefined;
+  /**
+   * Generate the id attribute (i.e.: the `id` attribute passed to the DOM element) of a Tree Item.
+   * If the user explicitly defined an id attribute, it will be returned.
+   * Otherwise, the method creates a unique id for the item based on the Tree View id attribute and the item `itemId`
+   */
+  treeItemIdAttribute: (args_0: MinimalTreeViewState<any, any>, itemId: string, providedIdAttribute: string | undefined) => string;
+};

package/esm/internals/plugins/id/selectors.js

@@ -0,0 +1,18 @@
+import { createSelector } from '@mui/x-internals/store';
+export const idSelectors = {
+  /**
+   * Get the id attribute of the tree view.
+   */
+  treeId: createSelector(state => state.treeId),
+  /**
+   * Generate the id attribute (i.e.: the `id` attribute passed to the DOM element) of a Tree Item.
+   * If the user explicitly defined an id attribute, it will be returned.
+   * Otherwise, the method creates a unique id for the item based on the Tree View id attribute and the item `itemId`
+   */
+  treeItemIdAttribute: createSelector(state => state.treeId, (treeId, itemId, providedIdAttribute) => {
+    if (providedIdAttribute != null) {
+      return providedIdAttribute;
+    }
+    return `${treeId ?? ''}-${itemId}`;
+  })
+};

package/esm/internals/plugins/items/TreeViewItemsPlugin.d.ts

@@ -0,0 +1,105 @@
+import { TreeViewItemId, TreeViewValidItem } from "../../../models/index.js";
+import { MinimalTreeViewParameters } from "../../MinimalTreeViewStore/MinimalTreeViewStore.types.js";
+export declare class TreeViewItemsPlugin<R extends TreeViewValidItem<R>> {
+  private store;
+  constructor(store: any);
+  /**
+   * Determines if the items state should be rebuilt based on the new and previous parameters.
+   */
+  static shouldRebuildItemsState: <R2 extends TreeViewValidItem<R2>>(newParameters: MinimalTreeViewParameters<R2, any>, previousParameters: MinimalTreeViewParameters<R2, any>) => boolean;
+  /**
+   * Builds the state properties derived from the `items` prop.
+   */
+  static buildItemsStateIfNeeded: <R2 extends TreeViewValidItem<R2>>(parameters: Pick<MinimalTreeViewParameters<R2, any>, "items" | "isItemDisabled" | "isItemSelectionDisabled" | "getItemId" | "getItemLabel" | "getItemChildren">) => {
+    itemMetaLookup: {
+      [itemId: string]: import("../../index.js").TreeViewItemMeta;
+    };
+    itemModelLookup: {
+      [itemId: string]: R2;
+    };
+    itemOrderedChildrenIdsLookup: {
+      [parentItemId: string]: string[];
+    };
+    itemChildrenIndexesLookup: {
+      [parentItemId: string]: {
+        [itemId: string]: number;
+      };
+    };
+  };
+  /**
+   * Get the item with the given id.
+   * When used in the Simple Tree View, it returns an object with the `id` and `label` properties.
+   * @param {TreeViewItemId} itemId The id of the item to retrieve.
+   * @returns {R} The item with the given id.
+   */
+  private getItem;
+  /**
+   * Get all the items in the same format as provided by `props.items`.
+   * @returns {R[]} The items in the tree.
+   */
+  private getItemTree;
+  /**
+   * Get the ids of a given item's children.
+   * Those ids are returned in the order they should be rendered.
+   * To get the root items, pass `null` as the `itemId`.
+   * @param {TreeViewItemId | null} itemId The id of the item to get the children of.
+   * @returns {TreeViewItemId[]} The ids of the item's children.
+   */
+  private getItemOrderedChildrenIds;
+  /** * Get the id of the parent item.
+   * @param {TreeViewItemId} itemId The id of the item to whose parentId we want to retrieve.
+   * @returns {TreeViewItemId | null} The id of the parent item.
+   */
+  private getParentId;
+  /**
+   * Toggle the disabled state of the item with the given id.
+   * @param {object} parameters The params of the method.
+   * @param {TreeViewItemId } parameters.itemId The id of the item to get the children of.
+   * @param {boolean } parameters.shouldBeDisabled true if the item should be disabled.
+   */
+  private setIsItemDisabled;
+  buildPublicAPI: () => {
+    getItem: (itemId: TreeViewItemId) => R;
+    getItemDOMElement: (itemId: TreeViewItemId) => HTMLElement | null;
+    getItemOrderedChildrenIds: (itemId: TreeViewItemId | null) => TreeViewItemId[];
+    getItemTree: () => R[];
+    getParentId: (itemId: TreeViewItemId) => TreeViewItemId | null;
+    setIsItemDisabled: ({
+      itemId,
+      shouldBeDisabled
+    }: {
+      itemId: TreeViewItemId;
+      shouldBeDisabled?: boolean;
+    }) => void;
+  };
+  /**
+   * Get the DOM element of the item with the given id.
+   * @param {TreeViewItemId} itemId The id of the item to get the DOM element of.
+   * @returns {HTMLElement | null} The DOM element of the item with the given id.
+   */
+  getItemDOMElement: (itemId: TreeViewItemId) => HTMLElement | null;
+  /**
+   * Add an array of items to the tree.
+   * @param {SetItemChildrenParameters<R>} args The items to add to the tree and information about their ancestors.
+   */
+  setItemChildren: ({
+    items,
+    parentId,
+    getChildrenCount
+  }: {
+    items: readonly R[];
+    parentId: TreeViewItemId | null;
+    getChildrenCount: (item: R) => number;
+  }) => void;
+  /**
+   * Remove the children of an item.
+   * @param {TreeViewItemId | null} parentId The id of the item to remove the children of.
+   */
+  removeChildren: (parentId: TreeViewItemId | null) => void;
+  /**
+   * Callback fired when the `content` slot of a given Tree Item is clicked.
+   * @param {React.MouseEvent} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} itemId The id of the item being clicked.
+   */
+  handleItemClick: (event: React.MouseEvent, itemId: TreeViewItemId) => void;
+}

package/esm/internals/plugins/items/TreeViewItemsPlugin.js

@@ -0,0 +1,223 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { idSelectors } from "../id/index.js";
+import { itemsSelectors } from "./selectors.js";
+import { buildItemsLookups, TREE_VIEW_ROOT_PARENT_ID } from "./utils.js";
+export class TreeViewItemsPlugin {
+  // We can't type `store`, otherwise we get the following TS error:
+  // 'items' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.
+  constructor(store) {
+    this.store = store;
+  }
+
+  /**
+   * Determines if the items state should be rebuilt based on the new and previous parameters.
+   */
+  static shouldRebuildItemsState = (newParameters, previousParameters) => {
+    return ['items', 'isItemDisabled', 'isItemSelectionDisabled', 'getItemId', 'getItemLabel', 'getItemChildren'].some(key => {
+      const typedKey = key;
+      return newParameters[typedKey] !== previousParameters[typedKey];
+    });
+  };
+
+  /**
+   * Builds the state properties derived from the `items` prop.
+   */
+  static buildItemsStateIfNeeded = parameters => {
+    const itemMetaLookup = {};
+    const itemModelLookup = {};
+    const itemOrderedChildrenIdsLookup = {};
+    const itemChildrenIndexesLookup = {};
+    function processSiblings(items, parentId, depth) {
+      const parentIdWithDefault = parentId ?? TREE_VIEW_ROOT_PARENT_ID;
+      const {
+        metaLookup,
+        modelLookup,
+        orderedChildrenIds,
+        childrenIndexes,
+        itemsChildren
+      } = buildItemsLookups({
+        storeParameters: parameters,
+        items,
+        parentId,
+        depth,
+        isItemExpandable: (item, children) => !!children && children.length > 0,
+        otherItemsMetaLookup: itemMetaLookup
+      });
+      Object.assign(itemMetaLookup, metaLookup);
+      Object.assign(itemModelLookup, modelLookup);
+      itemOrderedChildrenIdsLookup[parentIdWithDefault] = orderedChildrenIds;
+      itemChildrenIndexesLookup[parentIdWithDefault] = childrenIndexes;
+      for (const item of itemsChildren) {
+        processSiblings(item.children || [], item.id, depth + 1);
+      }
+    }
+    processSiblings(parameters.items, null, 0);
+    return {
+      itemMetaLookup,
+      itemModelLookup,
+      itemOrderedChildrenIdsLookup,
+      itemChildrenIndexesLookup
+    };
+  };
+
+  /**
+   * Get the item with the given id.
+   * When used in the Simple Tree View, it returns an object with the `id` and `label` properties.
+   * @param {TreeViewItemId} itemId The id of the item to retrieve.
+   * @returns {R} The item with the given id.
+   */
+  getItem = itemId => itemsSelectors.itemModel(this.store.state, itemId);
+
+  /**
+   * Get all the items in the same format as provided by `props.items`.
+   * @returns {R[]} The items in the tree.
+   */
+  getItemTree = () => {
+    const getItemFromItemId = itemId => {
+      const item = itemsSelectors.itemModel(this.store.state, itemId);
+      const itemToMutate = _extends({}, item);
+      const newChildren = itemsSelectors.itemOrderedChildrenIds(this.store.state, itemId);
+      if (newChildren.length > 0) {
+        itemToMutate.children = newChildren.map(getItemFromItemId);
+      } else {
+        delete itemToMutate.children;
+      }
+      return itemToMutate;
+    };
+    return itemsSelectors.itemOrderedChildrenIds(this.store.state, null).map(getItemFromItemId);
+  };
+
+  /**
+   * Get the ids of a given item's children.
+   * Those ids are returned in the order they should be rendered.
+   * To get the root items, pass `null` as the `itemId`.
+   * @param {TreeViewItemId | null} itemId The id of the item to get the children of.
+   * @returns {TreeViewItemId[]} The ids of the item's children.
+   */
+  getItemOrderedChildrenIds = itemId => itemsSelectors.itemOrderedChildrenIds(this.store.state, itemId);
+
+  /** * Get the id of the parent item.
+   * @param {TreeViewItemId} itemId The id of the item to whose parentId we want to retrieve.
+   * @returns {TreeViewItemId | null} The id of the parent item.
+   */
+  getParentId = itemId => {
+    const itemMeta = itemsSelectors.itemMeta(this.store.state, itemId);
+    return itemMeta?.parentId || null;
+  };
+
+  /**
+   * Toggle the disabled state of the item with the given id.
+   * @param {object} parameters The params of the method.
+   * @param {TreeViewItemId } parameters.itemId The id of the item to get the children of.
+   * @param {boolean } parameters.shouldBeDisabled true if the item should be disabled.
+   */
+  setIsItemDisabled = ({
+    itemId,
+    shouldBeDisabled
+  }) => {
+    if (!this.store.state.itemMetaLookup[itemId]) {
+      return;
+    }
+    const itemMetaLookup = _extends({}, this.store.state.itemMetaLookup);
+    itemMetaLookup[itemId] = _extends({}, itemMetaLookup[itemId], {
+      disabled: shouldBeDisabled ?? !itemMetaLookup[itemId].disabled
+    });
+    this.store.set('itemMetaLookup', itemMetaLookup);
+  };
+  buildPublicAPI = () => {
+    return {
+      getItem: this.getItem,
+      getItemDOMElement: this.getItemDOMElement,
+      getItemOrderedChildrenIds: this.getItemOrderedChildrenIds,
+      getItemTree: this.getItemTree,
+      getParentId: this.getParentId,
+      setIsItemDisabled: this.setIsItemDisabled
+    };
+  };
+
+  /**
+   * Get the DOM element of the item with the given id.
+   * @param {TreeViewItemId} itemId The id of the item to get the DOM element of.
+   * @returns {HTMLElement | null} The DOM element of the item with the given id.
+   */
+  getItemDOMElement = itemId => {
+    const itemMeta = itemsSelectors.itemMeta(this.store.state, itemId);
+    if (itemMeta == null) {
+      return null;
+    }
+    const idAttribute = idSelectors.treeItemIdAttribute(this.store.state, itemId, itemMeta.idAttribute);
+    return document.getElementById(idAttribute);
+  };
+
+  /**
+   * Add an array of items to the tree.
+   * @param {SetItemChildrenParameters<R>} args The items to add to the tree and information about their ancestors.
+   */
+  setItemChildren = ({
+    items,
+    parentId,
+    getChildrenCount
+  }) => {
+    const parentIdWithDefault = parentId ?? TREE_VIEW_ROOT_PARENT_ID;
+    const parentDepth = parentId == null ? -1 : itemsSelectors.itemDepth(this.store.state, parentId);
+    const {
+      metaLookup,
+      modelLookup,
+      orderedChildrenIds,
+      childrenIndexes
+    } = buildItemsLookups({
+      storeParameters: this.store.parameters,
+      items,
+      parentId,
+      depth: parentDepth + 1,
+      isItemExpandable: getChildrenCount ? item => getChildrenCount(item) !== 0 : () => false,
+      otherItemsMetaLookup: itemsSelectors.itemMetaLookup(this.store.state)
+    });
+    this.store.update({
+      itemModelLookup: _extends({}, this.store.state.itemModelLookup, modelLookup),
+      itemMetaLookup: _extends({}, this.store.state.itemMetaLookup, metaLookup),
+      itemOrderedChildrenIdsLookup: _extends({}, this.store.state.itemOrderedChildrenIdsLookup, {
+        [parentIdWithDefault]: orderedChildrenIds
+      }),
+      itemChildrenIndexesLookup: _extends({}, this.store.state.itemChildrenIndexesLookup, {
+        [parentIdWithDefault]: childrenIndexes
+      })
+    });
+  };
+
+  /**
+   * Remove the children of an item.
+   * @param {TreeViewItemId | null} parentId The id of the item to remove the children of.
+   */
+  removeChildren = parentId => {
+    const itemMetaLookup = this.store.state.itemMetaLookup;
+    const newMetaMap = Object.keys(itemMetaLookup).reduce((acc, key) => {
+      const item = itemMetaLookup[key];
+      if (item.parentId === parentId) {
+        return acc;
+      }
+      return _extends({}, acc, {
+        [item.id]: item
+      });
+    }, {});
+    const newItemOrderedChildrenIdsLookup = _extends({}, this.store.state.itemOrderedChildrenIdsLookup);
+    const newItemChildrenIndexesLookup = _extends({}, this.store.state.itemChildrenIndexesLookup);
+    const cleanId = parentId ?? TREE_VIEW_ROOT_PARENT_ID;
+    delete newItemChildrenIndexesLookup[cleanId];
+    delete newItemOrderedChildrenIdsLookup[cleanId];
+    this.store.update({
+      itemMetaLookup: newMetaMap,
+      itemOrderedChildrenIdsLookup: newItemOrderedChildrenIdsLookup,
+      itemChildrenIndexesLookup: newItemChildrenIndexesLookup
+    });
+  };
+
+  /**
+   * Callback fired when the `content` slot of a given Tree Item is clicked.
+   * @param {React.MouseEvent} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} itemId The id of the item being clicked.
+   */
+  handleItemClick = (event, itemId) => {
+    this.store.parameters.onItemClick?.(event, itemId);
+  };
+}

package/esm/internals/plugins/items/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./TreeViewItemsPlugin.js";
+export * from "./selectors.js";
+export { buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from "./utils.js";

package/esm/internals/plugins/items/index.js

@@ -0,0 +1,3 @@
+export * from "./TreeViewItemsPlugin.js";
+export * from "./selectors.js";
+export { buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from "./utils.js";

package/esm/internals/plugins/items/selectors.d.ts

@@ -0,0 +1,60 @@
+import { TreeViewItemMeta } from "../../models/index.js";
+import { MinimalTreeViewState } from "../../MinimalTreeViewStore/index.js";
+export declare const itemsSelectors: {
+  /**
+   * Gets the DOM structure of the Tree View.
+   */
+  domStructure: (state: MinimalTreeViewState<any, any>) => "flat" | "nested";
+  /**
+   * Checks whether the disabled items are focusable.
+   */
+  disabledItemFocusable: (state: MinimalTreeViewState<any, any>) => boolean;
+  /**
+   * Gets the meta-information of all items.
+   */
+  itemMetaLookup: (state: MinimalTreeViewState<any, any>) => {
+    [itemId: string]: TreeViewItemMeta;
+  };
+  /**
+   * Gets the ordered children ids of all items.
+   */
+  itemOrderedChildrenIdsLookup: (state: MinimalTreeViewState<any, any>) => {
+    [parentItemId: string]: string[];
+  };
+  /**
+   * Gets the meta-information of an item.
+   */
+  itemMeta: (state: MinimalTreeViewState<any, any>, itemId: string | null) => TreeViewItemMeta | null;
+  /**
+   * Gets the ordered children ids of an item.
+   */
+  itemOrderedChildrenIds: (state: MinimalTreeViewState<any, any>, itemId: string | null) => string[];
+  /**
+   * Gets the model of an item.
+   */
+  itemModel: (state: MinimalTreeViewState<any, any>, itemId: string) => any;
+  /**
+   * Checks whether an item is disabled.
+   */
+  isItemDisabled: (state: MinimalTreeViewState<any, any>, itemId: string) => boolean;
+  /**
+   * Gets the index of an item in its parent's children.
+   */
+  itemIndex: (state: MinimalTreeViewState<any, any>, itemId: string) => number;
+  /**
+   * Gets the id of an item's parent.
+   */
+  itemParentId: (state: MinimalTreeViewState<any, any>, itemId: string) => string | null;
+  /**
+   * Gets the depth of an item (items at the root level have a depth of 0).
+   */
+  itemDepth: (state: MinimalTreeViewState<any, any>, itemId: string) => number;
+  /**
+   * Checks whether an item can be focused.
+   */
+  canItemBeFocused: (state: MinimalTreeViewState<any, any>, itemId: string) => boolean;
+  /**
+   * Gets the identation between an item and its children.
+   */
+  itemChildrenIndentation: (state: MinimalTreeViewState<any, any>) => string | number;
+};

package/esm/internals/plugins/items/selectors.js

@@ -0,0 +1,64 @@
+import { createSelector } from '@mui/x-internals/store';
+import { isItemDisabled, TREE_VIEW_ROOT_PARENT_ID } from "./utils.js";
+const EMPTY_CHILDREN = [];
+export const itemsSelectors = {
+  /**
+   * Gets the DOM structure of the Tree View.
+   */
+  domStructure: createSelector(state => state.domStructure),
+  /**
+   * Checks whether the disabled items are focusable.
+   */
+  disabledItemFocusable: createSelector(state => state.disabledItemsFocusable),
+  /**
+   * Gets the meta-information of all items.
+   */
+  itemMetaLookup: createSelector(state => state.itemMetaLookup),
+  /**
+   * Gets the ordered children ids of all items.
+   */
+  itemOrderedChildrenIdsLookup: createSelector(state => state.itemOrderedChildrenIdsLookup),
+  /**
+   * Gets the meta-information of an item.
+   */
+  itemMeta: createSelector((state, itemId) => state.itemMetaLookup[itemId ?? TREE_VIEW_ROOT_PARENT_ID] ?? null),
+  /**
+   * Gets the ordered children ids of an item.
+   */
+  itemOrderedChildrenIds: createSelector((state, itemId) => state.itemOrderedChildrenIdsLookup[itemId ?? TREE_VIEW_ROOT_PARENT_ID] ?? EMPTY_CHILDREN),
+  /**
+   * Gets the model of an item.
+   */
+  itemModel: createSelector((state, itemId) => state.itemModelLookup[itemId]),
+  /**
+   * Checks whether an item is disabled.
+   */
+  isItemDisabled: createSelector((state, itemId) => isItemDisabled(state.itemMetaLookup, itemId)),
+  /**
+   * Gets the index of an item in its parent's children.
+   */
+  itemIndex: createSelector((state, itemId) => {
+    const itemMeta = state.itemMetaLookup[itemId];
+    if (itemMeta == null) {
+      return -1;
+    }
+    const parentIndexes = state.itemChildrenIndexesLookup[itemMeta.parentId ?? TREE_VIEW_ROOT_PARENT_ID];
+    return parentIndexes[itemMeta.id];
+  }),
+  /**
+   * Gets the id of an item's parent.
+   */
+  itemParentId: createSelector((state, itemId) => state.itemMetaLookup[itemId]?.parentId ?? null),
+  /**
+   * Gets the depth of an item (items at the root level have a depth of 0).
+   */
+  itemDepth: createSelector((state, itemId) => state.itemMetaLookup[itemId]?.depth ?? 0),
+  /**
+   * Checks whether an item can be focused.
+   */
+  canItemBeFocused: createSelector((state, itemId) => state.disabledItemsFocusable || !isItemDisabled(state.itemMetaLookup, itemId)),
+  /**
+   * Gets the identation between an item and its children.
+   */
+  itemChildrenIndentation: createSelector(state => state.itemChildrenIndentation)
+};

package/esm/internals/plugins/items/utils.d.ts

@@ -0,0 +1,43 @@
+import { TreeViewValidItem, TreeViewItemId } from "../../../models/index.js";
+import { TreeViewItemMeta } from "../../models/index.js";
+import type { MinimalTreeViewParameters } from "../../MinimalTreeViewStore/index.js";
+export declare const TREE_VIEW_ROOT_PARENT_ID = "__TREE_VIEW_ROOT_PARENT_ID__";
+export declare const buildSiblingIndexes: (siblings: string[]) => {
+  [itemId: string]: number;
+};
+/**
+ * Check if an item is disabled.
+ * This method should only be used in selectors that are checking if several items are disabled.
+ * Otherwise, use the `itemsSelector.isItemDisabled` selector.
+ * @returns
+ */
+export declare const isItemDisabled: (itemMetaLookup: {
+  [itemId: string]: TreeViewItemMeta;
+}, itemId: TreeViewItemId) => boolean;
+export declare function buildItemsLookups<R extends TreeViewValidItem<R>>(parameters: BuildItemsLookupsParameters<R>): {
+  metaLookup: {
+    [itemId: string]: TreeViewItemMeta;
+  };
+  modelLookup: {
+    [itemId: string]: R;
+  };
+  orderedChildrenIds: string[];
+  childrenIndexes: {
+    [itemId: string]: number;
+  };
+  itemsChildren: {
+    id: string | null;
+    children: R[];
+  }[];
+};
+interface BuildItemsLookupsParameters<R extends TreeViewValidItem<R>> {
+  items: readonly R[];
+  storeParameters: Pick<MinimalTreeViewParameters<R, any>, 'getItemId' | 'getItemLabel' | 'getItemChildren' | 'isItemDisabled' | 'isItemSelectionDisabled'>;
+  parentId: string | null;
+  depth: number;
+  isItemExpandable: (item: R, children: R[] | undefined) => boolean;
+  otherItemsMetaLookup: {
+    [itemId: string]: TreeViewItemMeta;
+  };
+}
+export {};

package/esm/internals/plugins/{useTreeViewItems/useTreeViewItems.utils.js → items/utils.js}

@@ -37,53 +37,9 @@ export const isItemDisabled = (itemMetaLookup, itemId) => {
   }
   return false;
 };
-export function buildItemsState(parameters) {
-  const {
-    config,
-    items: itemsParam,
-    disabledItemsFocusable
-  } = parameters;
-  const itemMetaLookup = {};
-  const itemModelLookup = {};
-  const itemOrderedChildrenIdsLookup = {};
-  const itemChildrenIndexesLookup = {};
-  function processSiblings(items, parentId, depth) {
-    const parentIdWithDefault = parentId ?? TREE_VIEW_ROOT_PARENT_ID;
-    const {
-      metaLookup,
-      modelLookup,
-      orderedChildrenIds,
-      childrenIndexes,
-      itemsChildren
-    } = buildItemsLookups({
-      config,
-      items,
-      parentId,
-      depth,
-      isItemExpandable: (item, children) => !!children && children.length > 0,
-      otherItemsMetaLookup: itemMetaLookup
-    });
-    Object.assign(itemMetaLookup, metaLookup);
-    Object.assign(itemModelLookup, modelLookup);
-    itemOrderedChildrenIdsLookup[parentIdWithDefault] = orderedChildrenIds;
-    itemChildrenIndexesLookup[parentIdWithDefault] = childrenIndexes;
-    for (const item of itemsChildren) {
-      processSiblings(item.children || [], item.id, depth + 1);
-    }
-  }
-  processSiblings(itemsParam, null, 0);
-  return {
-    disabledItemsFocusable,
-    itemMetaLookup,
-    itemModelLookup,
-    itemOrderedChildrenIdsLookup,
-    itemChildrenIndexesLookup,
-    domStructure: 'nested'
-  };
-}
 export function buildItemsLookups(parameters) {
   const {
-    config,
+    storeParameters,
     items,
     parentId,
     depth,
@@ -95,7 +51,7 @@ export function buildItemsLookups(parameters) {
   const orderedChildrenIds = [];
   const itemsChildren = [];
   const processItem = item => {
-    const id = config.getItemId ? config.getItemId(item) : item.id;
+    const id = storeParameters.getItemId ? storeParameters.getItemId(item) : item.id;
     checkId({
       id,
       parentId,
@@ -103,11 +59,11 @@ export function buildItemsLookups(parameters) {
       itemMetaLookup: otherItemsMetaLookup,
       siblingsMetaLookup: metaLookup
     });
-    const label = config.getItemLabel ? config.getItemLabel(item) : item.label;
+    const label = storeParameters.getItemLabel ? storeParameters.getItemLabel(item) : item.label;
     if (label == null) {
       throw new Error(['MUI X: The Tree View component requires all items to have a `label` property.', 'Alternatively, you can use the `getItemLabel` prop to specify a custom label for each item.', 'An item was provided without label in the `items` prop:', JSON.stringify(item)].join('\n'));
     }
-    const children = (config.getItemChildren ? config.getItemChildren(item) : item.children) || [];
+    const children = (storeParameters.getItemChildren ? storeParameters.getItemChildren(item) : item.children) || [];
     itemsChildren.push({
       id,
       children
@@ -119,8 +75,8 @@ export function buildItemsLookups(parameters) {
       parentId,
       idAttribute: undefined,
       expandable: isItemExpandable(item, children),
-      disabled: config.isItemDisabled ? config.isItemDisabled(item) : false,
-      selectable: config.isItemSelectionDisabled ? !config.isItemSelectionDisabled(item) : true,
+      disabled: storeParameters.isItemDisabled ? storeParameters.isItemDisabled(item) : false,
+      selectable: storeParameters.isItemSelectionDisabled ? !storeParameters.isItemSelectionDisabled(item) : true,
       depth
     };
     orderedChildrenIds.push(id);

package/esm/internals/plugins/{useTreeViewJSXItems/useTreeViewJSXItems.types.d.ts → jsxItems/TreeViewJSXItemsPlugin.d.ts}

@@ -1,8 +1,9 @@
-import { TreeViewItemMeta, TreeViewPluginSignature } from "../../models/index.js";
-import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
-import { UseTreeViewKeyboardNavigationSignature } from "../useTreeViewKeyboardNavigation/index.js";
 import { TreeViewItemId } from "../../../models/index.js";
-export interface UseTreeViewItemsInstance {
+import { TreeViewItemMeta } from "../../models/index.js";
+import type { SimpleTreeViewStore } from "../../SimpleTreeViewStore/index.js";
+export declare class TreeViewJSXItemsPlugin {
+  private store;
+  constructor(store: SimpleTreeViewStore<any>);
   /**
    * Insert a new item in the state from a Tree Item component.
    * @param {TreeViewItemMeta} item The meta-information of the item to insert.
@@ -24,12 +25,4 @@ export interface UseTreeViewItemsInstance {
    * @param {TreeViewItemId[]} orderedChildrenIds The ids of the item's children.
    */
   setJSXItemsOrderedChildrenIds: (parentId: TreeViewItemId | null, orderedChildrenIds: TreeViewItemId[]) => void;
-}
-export interface UseTreeViewJSXItemsParameters {}
-export interface UseTreeViewItemsParametersWithDefaults {}
-export type UseTreeViewJSXItemsSignature = TreeViewPluginSignature<{
-  params: UseTreeViewJSXItemsParameters;
-  paramsWithDefaults: UseTreeViewItemsParametersWithDefaults;
-  instance: UseTreeViewItemsInstance;
-  dependencies: [UseTreeViewItemsSignature, UseTreeViewKeyboardNavigationSignature];
-}>;
+}