@mui/x-tree-view 8.22.0 → 8.24.0

package/esm/internals/plugins/useTreeViewItems/useTreeViewItems.js

@@ -1,218 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useEventCallback } from '@base-ui-components/utils/useEventCallback';
-import { buildItemsLookups, buildItemsState, TREE_VIEW_ROOT_PARENT_ID } from "./useTreeViewItems.utils.js";
-import { TreeViewItemDepthContext } from "../../TreeViewItemDepthContext/index.js";
-import { itemsSelectors } from "./useTreeViewItems.selectors.js";
-import { idSelectors } from "../../corePlugins/useTreeViewId/index.js";
-import { generateTreeItemIdAttribute } from "../../corePlugins/useTreeViewId/useTreeViewId.utils.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-export const useTreeViewItems = ({
-  instance,
-  params,
-  store
-}) => {
-  const itemsConfig = React.useMemo(() => ({
-    isItemDisabled: params.isItemDisabled,
-    getItemLabel: params.getItemLabel,
-    getItemChildren: params.getItemChildren,
-    getItemId: params.getItemId
-  }), [params.isItemDisabled, params.getItemLabel, params.getItemChildren, params.getItemId]);
-  const getItem = React.useCallback(itemId => itemsSelectors.itemModel(store.state, itemId), [store]);
-  const getParentId = React.useCallback(itemId => {
-    const itemMeta = itemsSelectors.itemMeta(store.state, itemId);
-    return itemMeta?.parentId || null;
-  }, [store]);
-  const setIsItemDisabled = useEventCallback(({
-    itemId,
-    shouldBeDisabled
-  }) => {
-    if (!store.state.items.itemMetaLookup[itemId]) {
-      return;
-    }
-    const itemMetaLookup = _extends({}, store.state.items.itemMetaLookup);
-    itemMetaLookup[itemId] = _extends({}, itemMetaLookup[itemId], {
-      disabled: shouldBeDisabled ?? !itemMetaLookup[itemId].disabled
-    });
-    store.set('items', _extends({}, store.state.items, {
-      itemMetaLookup
-    }));
-  });
-  const getItemTree = React.useCallback(() => {
-    const getItemFromItemId = itemId => {
-      const item = itemsSelectors.itemModel(store.state, itemId);
-      const itemToMutate = _extends({}, item);
-      const newChildren = itemsSelectors.itemOrderedChildrenIds(store.state, itemId);
-      if (newChildren.length > 0) {
-        itemToMutate.children = newChildren.map(getItemFromItemId);
-      } else {
-        delete itemToMutate.children;
-      }
-      return itemToMutate;
-    };
-    return itemsSelectors.itemOrderedChildrenIds(store.state, null).map(getItemFromItemId);
-  }, [store]);
-  const getItemOrderedChildrenIds = React.useCallback(itemId => itemsSelectors.itemOrderedChildrenIds(store.state, itemId), [store]);
-  const getItemDOMElement = itemId => {
-    const itemMeta = itemsSelectors.itemMeta(store.state, itemId);
-    if (itemMeta == null) {
-      return null;
-    }
-    const idAttribute = generateTreeItemIdAttribute({
-      treeId: idSelectors.treeId(store.state),
-      itemId,
-      id: itemMeta.idAttribute
-    });
-    return document.getElementById(idAttribute);
-  };
-  const areItemUpdatesPreventedRef = React.useRef(false);
-  const preventItemUpdates = React.useCallback(() => {
-    areItemUpdatesPreventedRef.current = true;
-  }, []);
-  const areItemUpdatesPrevented = React.useCallback(() => areItemUpdatesPreventedRef.current, []);
-  const setItemChildren = ({
-    items,
-    parentId,
-    getChildrenCount
-  }) => {
-    const parentIdWithDefault = parentId ?? TREE_VIEW_ROOT_PARENT_ID;
-    const parentDepth = parentId == null ? -1 : itemsSelectors.itemDepth(store.state, parentId);
-    const {
-      metaLookup,
-      modelLookup,
-      orderedChildrenIds,
-      childrenIndexes
-    } = buildItemsLookups({
-      config: itemsConfig,
-      items,
-      parentId,
-      depth: parentDepth + 1,
-      isItemExpandable: getChildrenCount ? item => getChildrenCount(item) > 0 : () => false,
-      otherItemsMetaLookup: itemsSelectors.itemMetaLookup(store.state)
-    });
-    const lookups = {
-      itemModelLookup: _extends({}, store.state.items.itemModelLookup, modelLookup),
-      itemMetaLookup: _extends({}, store.state.items.itemMetaLookup, metaLookup),
-      itemOrderedChildrenIdsLookup: _extends({}, store.state.items.itemOrderedChildrenIdsLookup, {
-        [parentIdWithDefault]: orderedChildrenIds
-      }),
-      itemChildrenIndexesLookup: _extends({}, store.state.items.itemChildrenIndexesLookup, {
-        [parentIdWithDefault]: childrenIndexes
-      })
-    };
-    store.set('items', _extends({}, store.state.items, lookups));
-  };
-  const removeChildren = useEventCallback(parentId => {
-    const newMetaMap = Object.keys(store.state.items.itemMetaLookup).reduce((acc, key) => {
-      const item = store.state.items.itemMetaLookup[key];
-      if (item.parentId === parentId) {
-        return acc;
-      }
-      return _extends({}, acc, {
-        [item.id]: item
-      });
-    }, {});
-    const newItemOrderedChildrenIdsLookup = _extends({}, store.state.items.itemOrderedChildrenIdsLookup);
-    const newItemChildrenIndexesLookup = _extends({}, store.state.items.itemChildrenIndexesLookup);
-    const cleanId = parentId ?? TREE_VIEW_ROOT_PARENT_ID;
-    delete newItemChildrenIndexesLookup[cleanId];
-    delete newItemOrderedChildrenIdsLookup[cleanId];
-    store.set('items', _extends({}, store.state.items, {
-      itemMetaLookup: newMetaMap,
-      itemOrderedChildrenIdsLookup: newItemOrderedChildrenIdsLookup,
-      itemChildrenIndexesLookup: newItemChildrenIndexesLookup
-    }));
-  });
-  const addExpandableItems = useEventCallback(items => {
-    const newItemMetaLookup = _extends({}, store.state.items.itemMetaLookup);
-    for (const itemId of items) {
-      newItemMetaLookup[itemId] = _extends({}, newItemMetaLookup[itemId], {
-        expandable: true
-      });
-    }
-    store.set('items', _extends({}, store.state.items, {
-      itemMetaLookup: newItemMetaLookup
-    }));
-  });
-  React.useEffect(() => {
-    if (instance.areItemUpdatesPrevented()) {
-      return;
-    }
-    const newState = buildItemsState({
-      disabledItemsFocusable: params.disabledItemsFocusable,
-      items: params.items,
-      config: itemsConfig
-    });
-    store.set('items', _extends({}, store.state.items, newState));
-  }, [instance, store, params.items, params.disabledItemsFocusable, itemsConfig]);
-
-  // Wrap `props.onItemClick` with `useEventCallback` to prevent unneeded context updates.
-  const handleItemClick = useEventCallback((event, itemId) => {
-    if (params.onItemClick) {
-      params.onItemClick(event, itemId);
-    }
-  });
-  return {
-    getRootProps: () => ({
-      style: {
-        '--TreeView-itemChildrenIndentation': typeof params.itemChildrenIndentation === 'number' ? `${params.itemChildrenIndentation}px` : params.itemChildrenIndentation
-      }
-    }),
-    publicAPI: {
-      getItem,
-      getItemDOMElement,
-      getItemTree,
-      getItemOrderedChildrenIds,
-      setIsItemDisabled,
-      getParentId
-    },
-    instance: {
-      getItemDOMElement,
-      preventItemUpdates,
-      areItemUpdatesPrevented,
-      setItemChildren,
-      removeChildren,
-      addExpandableItems,
-      handleItemClick
-    }
-  };
-};
-useTreeViewItems.getInitialState = params => ({
-  items: buildItemsState({
-    items: params.items,
-    disabledItemsFocusable: params.disabledItemsFocusable,
-    config: {
-      isItemDisabled: params.isItemDisabled,
-      getItemId: params.getItemId,
-      getItemLabel: params.getItemLabel,
-      getItemChildren: params.getItemChildren
-    }
-  })
-});
-useTreeViewItems.applyDefaultValuesToParams = ({
-  params
-}) => _extends({}, params, {
-  disabledItemsFocusable: params.disabledItemsFocusable ?? false,
-  itemChildrenIndentation: params.itemChildrenIndentation ?? '12px'
-});
-useTreeViewItems.wrapRoot = ({
-  children
-}) => {
-  return /*#__PURE__*/_jsx(TreeViewItemDepthContext.Provider, {
-    value: itemsSelectors.itemDepth,
-    children: children
-  });
-};
-if (process.env.NODE_ENV !== "production") useTreeViewItems.wrapRoot.displayName = "useTreeViewItems.wrapRoot";
-useTreeViewItems.params = {
-  disabledItemsFocusable: true,
-  items: true,
-  isItemDisabled: true,
-  getItemLabel: true,
-  getItemChildren: true,
-  getItemId: true,
-  onItemClick: true,
-  itemChildrenIndentation: true
-};

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

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

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

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

package/esm/internals/plugins/useTreeViewItems/useTreeViewItems.types.d.ts

@@ -1,197 +0,0 @@
-import * as React from 'react';
-import { DefaultizedProps } from '@mui/x-internals/types';
-import { TreeViewItemMeta, TreeViewPluginSignature } from "../../models/index.js";
-import { TreeViewBaseItem, TreeViewDefaultItemModelProperties, TreeViewItemId } from "../../../models/index.js";
-export type SetItemChildrenParameters<R> = {
-  items: readonly R[];
-  parentId: TreeViewItemId | null;
-  getChildrenCount: (item: R) => number;
-};
-export interface UseTreeViewItemsPublicAPI<R extends {}> {
-  /**
-   * 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: TreeViewItemId) => R;
-  /**
-   * 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;
-  /**
-   * 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: TreeViewItemId | null) => TreeViewItemId[];
-  /**
-   * Get all the items in the same format as provided by `props.items`.
-   * @returns {TreeViewBaseItem[]} The items in the tree.
-   */
-  getItemTree: () => TreeViewBaseItem[];
-  /**
-   * 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: (parameters: {
-    itemId: TreeViewItemId;
-    shouldBeDisabled?: boolean;
-  }) => void;
-  /** * 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: TreeViewItemId) => TreeViewItemId | null;
-}
-export interface UseTreeViewItemsInstance<R extends {}> extends Pick<UseTreeViewItemsPublicAPI<R>, 'getItemDOMElement'> {
-  /**
-   * Freeze any future update to the state based on the `items` prop.
-   * This is useful when `useTreeViewJSXItems` is used to avoid having conflicting sources of truth.
-   */
-  preventItemUpdates: () => void;
-  /**
-   * Check if the updates to the state based on the `items` prop are prevented.
-   * This is useful when `useTreeViewJSXItems` is used to avoid having conflicting sources of truth.
-   * @returns {boolean} `true` if the updates to the state based on the `items` prop are prevented.
-   */
-  areItemUpdatesPrevented: () => boolean;
-  /**
-   * 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: (args: SetItemChildrenParameters<R>) => 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;
-  /**
-   * Event handler to fire 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;
-  /**
-   * Mark a list of items as expandable.
-   * @param {TreeViewItemId[]} items The ids of the items to mark as expandable.
-   */
-  addExpandableItems: (items: TreeViewItemId[]) => void;
-}
-export interface UseTreeViewItemsParameters<R extends {
-  children?: R[];
-}> {
-  /**
-   * Whether the items should be focusable when disabled.
-   * @default false
-   */
-  disabledItemsFocusable?: boolean;
-  items: readonly R[];
-  /**
-   * Used to determine if a given item should be disabled.
-   * @template R
-   * @param {R} item The item to check.
-   * @returns {boolean} `true` if the item should be disabled.
-   */
-  isItemDisabled?: (item: R) => boolean;
-  /**
-   * Used to determine the string label for a given item.
-   *
-   * @template R
-   * @param {R} item The item to check.
-   * @returns {string} The label of the item.
-   * @default (item) => item.label
-   */
-  getItemLabel?: (item: R) => string;
-  /**
-   * Used to determine the children of a given item.
-   *
-   * @template R
-   * @param {R} item The item to check.
-   * @returns {R[]} The children of the item.
-   * @default (item) => item.children
-   */
-  getItemChildren?: (item: R) => R[] | undefined;
-  /**
-   * Used to determine the id of a given item.
-   *
-   * @template R
-   * @param {R} item The item to check.
-   * @returns {TreeViewItemId} The id of the item.
-   * @default (item) => item.id
-   */
-  getItemId?: (item: R) => TreeViewItemId;
-  /**
-   * 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 focused item.
-   */
-  onItemClick?: (event: React.MouseEvent, itemId: TreeViewItemId) => void;
-  /**
-   * Horizontal indentation between an item and its children.
-   * Examples: 24, "24px", "2rem", "2em".
-   * @default 12px
-   */
-  itemChildrenIndentation?: string | number;
-}
-export type UseTreeViewItemsParametersWithDefaults<R extends {
-  children?: R[];
-}> = DefaultizedProps<UseTreeViewItemsParameters<R>, 'disabledItemsFocusable' | 'itemChildrenIndentation'>;
-export interface UseTreeViewItemsState<R extends {}> {
-  items: {
-    /**
-     * Whether the items should be focusable when disabled.
-     * Always equal to `props.disabledItemsFocusable` (or `false` if not provided).
-     */
-    disabledItemsFocusable: boolean;
-    /**
-     * Model of each item as provided by `props.items` or by imperative items updates.
-     * It is not updated when properties derived from the model are updated:
-     * - when the label of an item is updated, `itemMetaLookup` is updated, not `itemModelLookup`.
-     * - when the children of an item are updated, `itemOrderedChildrenIdsLookup` and `itemChildrenIndexesLookup` are updated, not `itemModelLookup`.
-     * This means that the `children`, `label` or `id` properties of an item model should never be used directly, always use the structured sub-states instead.
-     */
-    itemModelLookup: {
-      [itemId: string]: TreeViewBaseItem<R>;
-    };
-    /**
-     * Meta data of each item.
-     */
-    itemMetaLookup: {
-      [itemId: string]: TreeViewItemMeta;
-    };
-    /**
-     * Ordered children ids of each item.
-     */
-    itemOrderedChildrenIdsLookup: {
-      [parentItemId: string]: TreeViewItemId[];
-    };
-    /**
-     * Index of each child in the ordered children ids of its parent.
-     */
-    itemChildrenIndexesLookup: {
-      [parentItemId: string]: {
-        [itemId: string]: number;
-      };
-    };
-    /**
-     * When equal to 'flat', the tree is rendered as a flat list (children are rendered as siblings of their parents).
-     * When equal to 'nested', the tree is rendered with nested children (children are rendered inside the groupTransition slot of their children).
-     * Nested DOM structure is not compatible with collapse / expansion animations.
-     */
-    domStructure: 'flat' | 'nested';
-  };
-}
-export type UseTreeViewItemsSignature = TreeViewPluginSignature<{
-  params: UseTreeViewItemsParameters<any>;
-  paramsWithDefaults: UseTreeViewItemsParametersWithDefaults<any>;
-  instance: UseTreeViewItemsInstance<any>;
-  publicAPI: UseTreeViewItemsPublicAPI<any>;
-  state: UseTreeViewItemsState<TreeViewDefaultItemModelProperties>;
-}>;

package/esm/internals/plugins/useTreeViewItems/useTreeViewItems.types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,49 +0,0 @@
-import { TreeViewBaseItem, TreeViewItemId } from "../../../models/index.js";
-import { TreeViewItemMeta } from "../../models/index.js";
-import { UseTreeViewItemsParametersWithDefaults, UseTreeViewItemsState } from "./useTreeViewItems.types.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;
-type State = UseTreeViewItemsState<any>['items'];
-export declare function buildItemsState(parameters: BuildItemsStateParameters): State;
-interface BuildItemsStateParameters extends Pick<BuildItemsLookupsParameters, 'items' | 'config'> {
-  disabledItemsFocusable: boolean;
-}
-export declare function buildItemsLookups(parameters: BuildItemsLookupsParameters): {
-  metaLookup: {
-    [itemId: string]: TreeViewItemMeta;
-  };
-  modelLookup: {
-    [itemId: string]: any;
-  };
-  orderedChildrenIds: string[];
-  childrenIndexes: {
-    [itemId: string]: number;
-  };
-  itemsChildren: {
-    id: string | null;
-    children: TreeViewBaseItem[];
-  }[];
-};
-interface BuildItemsLookupsParameters {
-  items: readonly TreeViewBaseItem[];
-  config: BuildItemsLookupConfig;
-  parentId: string | null;
-  depth: number;
-  isItemExpandable: (item: TreeViewBaseItem, children: TreeViewBaseItem[] | undefined) => boolean;
-  otherItemsMetaLookup: {
-    [itemId: string]: TreeViewItemMeta;
-  };
-}
-export interface BuildItemsLookupConfig extends Pick<UseTreeViewItemsParametersWithDefaults<TreeViewBaseItem>, 'isItemDisabled' | 'getItemLabel' | 'getItemChildren' | 'getItemId'> {}
-export {};

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

@@ -1,2 +0,0 @@
-export { useTreeViewJSXItems } from "./useTreeViewJSXItems.js";
-export type { UseTreeViewJSXItemsSignature, UseTreeViewJSXItemsParameters, UseTreeViewItemsParametersWithDefaults } from "./useTreeViewJSXItems.types.js";

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

@@ -1 +0,0 @@
-export { useTreeViewJSXItems } from "./useTreeViewJSXItems.js";

package/esm/internals/plugins/useTreeViewJSXItems/itemPlugin.d.ts

@@ -1,2 +0,0 @@
-import { TreeViewItemPlugin } from "../../models/index.js";
-export declare const useTreeViewJSXItemsItemPlugin: TreeViewItemPlugin;

package/esm/internals/plugins/useTreeViewJSXItems/itemPlugin.js

@@ -1,74 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { useStore } from '@mui/x-internals/store';
-import { useMergedRefs } from '@base-ui-components/utils/useMergedRefs';
-import { useIsoLayoutEffect } from '@base-ui-components/utils/useIsoLayoutEffect';
-import { useTreeViewContext } from "../../TreeViewProvider/index.js";
-import { TreeViewChildrenItemContext } from "../../TreeViewProvider/TreeViewChildrenItemProvider.js";
-import { itemHasChildren } from "../../../hooks/useTreeItemUtils/useTreeItemUtils.js";
-import { idSelectors } from "../../corePlugins/useTreeViewId/index.js";
-import { generateTreeItemIdAttribute } from "../../corePlugins/useTreeViewId/useTreeViewId.utils.js";
-export const useTreeViewJSXItemsItemPlugin = ({
-  props,
-  rootRef,
-  contentRef
-}) => {
-  const {
-    instance,
-    store
-  } = useTreeViewContext();
-  const {
-    children,
-    disabled = false,
-    label,
-    itemId,
-    id
-  } = props;
-  const parentContext = React.useContext(TreeViewChildrenItemContext);
-  if (parentContext == null) {
-    throw new Error(['MUI X: Could not find the Tree View Children Item context.', 'It looks like you rendered your component outside of a SimpleTreeView parent component.', 'This can also happen if you are bundling multiple versions of the Tree View.'].join('\n'));
-  }
-  const {
-    registerChild,
-    unregisterChild,
-    parentId
-  } = parentContext;
-  const expandable = itemHasChildren(children);
-  const pluginContentRef = React.useRef(null);
-  const handleContentRef = useMergedRefs(pluginContentRef, contentRef);
-  const treeId = useStore(store, idSelectors.treeId);
-
-  // Prevent any flashing
-  useIsoLayoutEffect(() => {
-    const idAttribute = generateTreeItemIdAttribute({
-      itemId,
-      treeId,
-      id
-    });
-    registerChild(idAttribute, itemId);
-    return () => {
-      unregisterChild(idAttribute);
-      unregisterChild(idAttribute);
-    };
-  }, [store, instance, registerChild, unregisterChild, itemId, id, treeId]);
-  useIsoLayoutEffect(() => {
-    return instance.insertJSXItem({
-      id: itemId,
-      idAttribute: id,
-      parentId,
-      expandable,
-      disabled
-    });
-  }, [instance, parentId, itemId, expandable, disabled, id]);
-  React.useEffect(() => {
-    if (label) {
-      return instance.mapLabelFromJSX(itemId, (pluginContentRef.current?.textContent ?? '').toLowerCase());
-    }
-    return undefined;
-  }, [instance, itemId, label]);
-  return {
-    contentRef: handleContentRef,
-    rootRef
-  };
-};

package/esm/internals/plugins/useTreeViewJSXItems/useTreeViewJSXItems.d.ts

@@ -1,3 +0,0 @@
-import { TreeViewPlugin } from "../../models/index.js";
-import { UseTreeViewJSXItemsSignature } from "./useTreeViewJSXItems.types.js";
-export declare const useTreeViewJSXItems: TreeViewPlugin<UseTreeViewJSXItemsSignature>;