@mui/x-tree-view 8.23.0 → 8.24.0

package/internals/plugins/id/index.js

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

package/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/internals/plugins/id/selectors.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.idSelectors = void 0;
+var _store = require("@mui/x-internals/store");
+const idSelectors = exports.idSelectors = {
+  /**
+   * Get the id attribute of the tree view.
+   */
+  treeId: (0, _store.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: (0, _store.createSelector)(state => state.treeId, (treeId, itemId, providedIdAttribute) => {
+    if (providedIdAttribute != null) {
+      return providedIdAttribute;
+    }
+    return `${treeId ?? ''}-${itemId}`;
+  })
+};

package/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/internals/plugins/items/TreeViewItemsPlugin.js

@@ -0,0 +1,231 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TreeViewItemsPlugin = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _id = require("../id");
+var _selectors = require("./selectors");
+var _utils = require("./utils");
+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 ?? _utils.TREE_VIEW_ROOT_PARENT_ID;
+      const {
+        metaLookup,
+        modelLookup,
+        orderedChildrenIds,
+        childrenIndexes,
+        itemsChildren
+      } = (0, _utils.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 => _selectors.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 = _selectors.itemsSelectors.itemModel(this.store.state, itemId);
+      const itemToMutate = (0, _extends2.default)({}, item);
+      const newChildren = _selectors.itemsSelectors.itemOrderedChildrenIds(this.store.state, itemId);
+      if (newChildren.length > 0) {
+        itemToMutate.children = newChildren.map(getItemFromItemId);
+      } else {
+        delete itemToMutate.children;
+      }
+      return itemToMutate;
+    };
+    return _selectors.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 => _selectors.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 = _selectors.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 = (0, _extends2.default)({}, this.store.state.itemMetaLookup);
+    itemMetaLookup[itemId] = (0, _extends2.default)({}, 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 = _selectors.itemsSelectors.itemMeta(this.store.state, itemId);
+    if (itemMeta == null) {
+      return null;
+    }
+    const idAttribute = _id.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 ?? _utils.TREE_VIEW_ROOT_PARENT_ID;
+    const parentDepth = parentId == null ? -1 : _selectors.itemsSelectors.itemDepth(this.store.state, parentId);
+    const {
+      metaLookup,
+      modelLookup,
+      orderedChildrenIds,
+      childrenIndexes
+    } = (0, _utils.buildItemsLookups)({
+      storeParameters: this.store.parameters,
+      items,
+      parentId,
+      depth: parentDepth + 1,
+      isItemExpandable: getChildrenCount ? item => getChildrenCount(item) !== 0 : () => false,
+      otherItemsMetaLookup: _selectors.itemsSelectors.itemMetaLookup(this.store.state)
+    });
+    this.store.update({
+      itemModelLookup: (0, _extends2.default)({}, this.store.state.itemModelLookup, modelLookup),
+      itemMetaLookup: (0, _extends2.default)({}, this.store.state.itemMetaLookup, metaLookup),
+      itemOrderedChildrenIdsLookup: (0, _extends2.default)({}, this.store.state.itemOrderedChildrenIdsLookup, {
+        [parentIdWithDefault]: orderedChildrenIds
+      }),
+      itemChildrenIndexesLookup: (0, _extends2.default)({}, 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 (0, _extends2.default)({}, acc, {
+        [item.id]: item
+      });
+    }, {});
+    const newItemOrderedChildrenIdsLookup = (0, _extends2.default)({}, this.store.state.itemOrderedChildrenIdsLookup);
+    const newItemChildrenIndexesLookup = (0, _extends2.default)({}, this.store.state.itemChildrenIndexesLookup);
+    const cleanId = parentId ?? _utils.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);
+  };
+}
+exports.TreeViewItemsPlugin = TreeViewItemsPlugin;

package/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/internals/plugins/items/index.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  buildSiblingIndexes: true,
+  TREE_VIEW_ROOT_PARENT_ID: true
+};
+Object.defineProperty(exports, "TREE_VIEW_ROOT_PARENT_ID", {
+  enumerable: true,
+  get: function () {
+    return _utils.TREE_VIEW_ROOT_PARENT_ID;
+  }
+});
+Object.defineProperty(exports, "buildSiblingIndexes", {
+  enumerable: true,
+  get: function () {
+    return _utils.buildSiblingIndexes;
+  }
+});
+var _TreeViewItemsPlugin = require("./TreeViewItemsPlugin");
+Object.keys(_TreeViewItemsPlugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _TreeViewItemsPlugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _TreeViewItemsPlugin[key];
+    }
+  });
+});
+var _selectors = require("./selectors");
+Object.keys(_selectors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _selectors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _selectors[key];
+    }
+  });
+});
+var _utils = require("./utils");

package/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/internals/plugins/{useTreeViewItems/useTreeViewItems.selectors.js → items/selectors.js}

@@ -5,66 +5,66 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.itemsSelectors = void 0;
 var _store = require("@mui/x-internals/store");
-var _useTreeViewItems = require("./useTreeViewItems.utils");
+var _utils = require("./utils");
 const EMPTY_CHILDREN = [];
 const itemsSelectors = exports.itemsSelectors = {
   /**
    * Gets the DOM structure of the Tree View.
    */
-  domStructure: (0, _store.createSelector)(state => state.items.domStructure),
+  domStructure: (0, _store.createSelector)(state => state.domStructure),
   /**
    * Checks whether the disabled items are focusable.
    */
-  disabledItemFocusable: (0, _store.createSelector)(state => state.items.disabledItemsFocusable),
+  disabledItemFocusable: (0, _store.createSelector)(state => state.disabledItemsFocusable),
   /**
    * Gets the meta-information of all items.
    */
-  itemMetaLookup: (0, _store.createSelector)(state => state.items.itemMetaLookup),
+  itemMetaLookup: (0, _store.createSelector)(state => state.itemMetaLookup),
   /**
    * Gets the ordered children ids of all items.
    */
-  itemOrderedChildrenIdsLookup: (0, _store.createSelector)(state => state.items.itemOrderedChildrenIdsLookup),
+  itemOrderedChildrenIdsLookup: (0, _store.createSelector)(state => state.itemOrderedChildrenIdsLookup),
   /**
    * Gets the meta-information of an item.
    */
-  itemMeta: (0, _store.createSelector)((state, itemId) => state.items.itemMetaLookup[itemId ?? _useTreeViewItems.TREE_VIEW_ROOT_PARENT_ID] ?? null),
+  itemMeta: (0, _store.createSelector)((state, itemId) => state.itemMetaLookup[itemId ?? _utils.TREE_VIEW_ROOT_PARENT_ID] ?? null),
   /**
    * Gets the ordered children ids of an item.
    */
-  itemOrderedChildrenIds: (0, _store.createSelector)((state, itemId) => state.items.itemOrderedChildrenIdsLookup[itemId ?? _useTreeViewItems.TREE_VIEW_ROOT_PARENT_ID] ?? EMPTY_CHILDREN),
+  itemOrderedChildrenIds: (0, _store.createSelector)((state, itemId) => state.itemOrderedChildrenIdsLookup[itemId ?? _utils.TREE_VIEW_ROOT_PARENT_ID] ?? EMPTY_CHILDREN),
   /**
    * Gets the model of an item.
    */
-  itemModel: (0, _store.createSelector)((state, itemId) => state.items.itemModelLookup[itemId]),
+  itemModel: (0, _store.createSelector)((state, itemId) => state.itemModelLookup[itemId]),
   /**
    * Checks whether an item is disabled.
    */
-  isItemDisabled: (0, _store.createSelector)((state, itemId) => (0, _useTreeViewItems.isItemDisabled)(state.items.itemMetaLookup, itemId)),
+  isItemDisabled: (0, _store.createSelector)((state, itemId) => (0, _utils.isItemDisabled)(state.itemMetaLookup, itemId)),
   /**
    * Gets the index of an item in its parent's children.
    */
   itemIndex: (0, _store.createSelector)((state, itemId) => {
-    const itemMeta = state.items.itemMetaLookup[itemId];
+    const itemMeta = state.itemMetaLookup[itemId];
     if (itemMeta == null) {
       return -1;
     }
-    const parentIndexes = state.items.itemChildrenIndexesLookup[itemMeta.parentId ?? _useTreeViewItems.TREE_VIEW_ROOT_PARENT_ID];
+    const parentIndexes = state.itemChildrenIndexesLookup[itemMeta.parentId ?? _utils.TREE_VIEW_ROOT_PARENT_ID];
     return parentIndexes[itemMeta.id];
   }),
   /**
    * Gets the id of an item's parent.
    */
-  itemParentId: (0, _store.createSelector)((state, itemId) => state.items.itemMetaLookup[itemId]?.parentId ?? null),
+  itemParentId: (0, _store.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: (0, _store.createSelector)((state, itemId) => state.items.itemMetaLookup[itemId]?.depth ?? 0),
+  itemDepth: (0, _store.createSelector)((state, itemId) => state.itemMetaLookup[itemId]?.depth ?? 0),
   /**
    * Checks whether an item can be focused.
    */
-  canItemBeFocused: (0, _store.createSelector)((state, itemId) => state.items.disabledItemsFocusable || !(0, _useTreeViewItems.isItemDisabled)(state.items.itemMetaLookup, itemId)),
+  canItemBeFocused: (0, _store.createSelector)((state, itemId) => state.disabledItemsFocusable || !(0, _utils.isItemDisabled)(state.itemMetaLookup, itemId)),
   /**
-   * Checks whether an item is selectable based on the `isItemSelectionDisabled` prop.
+   * Gets the identation between an item and its children.
    */
-  isItemSelectable: (0, _store.createSelector)((state, itemId) => state.items.itemMetaLookup[itemId]?.selectable ?? true)
+  itemChildrenIndentation: (0, _store.createSelector)(state => state.itemChildrenIndentation)
 };

package/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 {};