@mui/x-tree-view 8.0.0-alpha.11 → 8.0.0-alpha.13

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

@@ -1,5 +1,11 @@
-import { createSelector } from "../../utils/selectors.js";
-import { TREE_VIEW_ROOT_PARENT_ID } from "./useTreeViewItems.utils.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectorItemParentId = exports.selectorItemOrderedChildrenIds = exports.selectorItemModel = exports.selectorItemMetaLookup = exports.selectorItemMeta = exports.selectorItemIndex = exports.selectorItemDepth = exports.selectorIsItemDisabled = exports.selectorCanItemBeFocused = void 0;
+var _selectors = require("../../utils/selectors");
+var _useTreeViewItems = require("./useTreeViewItems.utils");
 const selectorTreeViewItemsState = state => state.items;
 
 /**
@@ -7,7 +13,7 @@ const selectorTreeViewItemsState = state => state.items;
  * @param {TreeViewState<[UseTreeViewItemsSignature]>} state The state of the tree view.
  * @returns {TreeViewItemMetaLookup} The meta-information of all items.
  */
-export const selectorItemMetaLookup = createSelector(selectorTreeViewItemsState, items => items.itemMetaLookup);
+const selectorItemMetaLookup = exports.selectorItemMetaLookup = (0, _selectors.createSelector)(selectorTreeViewItemsState, items => items.itemMetaLookup);
 const EMPTY_CHILDREN = [];
 
 /**
@@ -16,7 +22,7 @@ const EMPTY_CHILDREN = [];
  * @param {TreeViewItemId} itemId The id of the item to get the children of.
  * @returns {TreeViewItemId[]} The ordered children ids of the item.
  */
-export const selectorItemOrderedChildrenIds = createSelector([selectorTreeViewItemsState, (_, itemId) => itemId], (itemsState, itemId) => itemsState.itemOrderedChildrenIdsLookup[itemId ?? TREE_VIEW_ROOT_PARENT_ID] ?? EMPTY_CHILDREN);
+const selectorItemOrderedChildrenIds = exports.selectorItemOrderedChildrenIds = (0, _selectors.createSelector)([selectorTreeViewItemsState, (_, itemId) => itemId], (itemsState, itemId) => itemsState.itemOrderedChildrenIdsLookup[itemId ?? _useTreeViewItems.TREE_VIEW_ROOT_PARENT_ID] ?? EMPTY_CHILDREN);
 
 /**
  * Get the model of an item.
@@ -24,7 +30,7 @@ export const selectorItemOrderedChildrenIds = createSelector([selectorTreeViewIt
  * @param {TreeViewItemId} itemId The id of the item to get the model of.
  * @returns {R} The model of the item.
  */
-export const selectorItemModel = createSelector([selectorTreeViewItemsState, (_, itemId) => itemId], (itemsState, itemId) => {
+const selectorItemModel = exports.selectorItemModel = (0, _selectors.createSelector)([selectorTreeViewItemsState, (_, itemId) => itemId], (itemsState, itemId) => {
   const a = itemsState.itemModelLookup[itemId];
   return a;
 });
@@ -36,7 +42,7 @@ export const selectorItemModel = createSelector([selectorTreeViewItemsState, (_,
  * @param {TreeViewItemId} itemId The id of the item to get the meta-information of.
  * @returns {TreeViewItemMeta | null} The meta-information of the item.
  */
-export const selectorItemMeta = createSelector([selectorItemMetaLookup, (_, itemId) => itemId], (itemMetaLookup, itemId) => itemMetaLookup[itemId ?? TREE_VIEW_ROOT_PARENT_ID] ?? null);
+const selectorItemMeta = exports.selectorItemMeta = (0, _selectors.createSelector)([selectorItemMetaLookup, (_, itemId) => itemId], (itemMetaLookup, itemId) => itemMetaLookup[itemId ?? _useTreeViewItems.TREE_VIEW_ROOT_PARENT_ID] ?? null);
 
 /**
  * Check if an item is disabled.
@@ -44,7 +50,7 @@ export const selectorItemMeta = createSelector([selectorItemMetaLookup, (_, item
  * @param {TreeViewItemId} itemId The id of the item to check.
  * @returns {boolean} `true` if the item is disabled, `false` otherwise.
  */
-export const selectorIsItemDisabled = createSelector([selectorItemMetaLookup, (_, itemId) => itemId], (itemMetaLookup, itemId) => {
+const selectorIsItemDisabled = exports.selectorIsItemDisabled = (0, _selectors.createSelector)([selectorItemMetaLookup, (_, itemId) => itemId], (itemMetaLookup, itemId) => {
   if (itemId == null) {
     return false;
   }
@@ -72,11 +78,11 @@ export const selectorIsItemDisabled = createSelector([selectorItemMetaLookup, (_
  * @param {TreeViewItemId} itemId The id of the item to get the index of.
  * @returns {number} The index of the item in its parent's children.
  */
-export const selectorItemIndex = createSelector([selectorTreeViewItemsState, selectorItemMeta], (itemsState, itemMeta) => {
+const selectorItemIndex = exports.selectorItemIndex = (0, _selectors.createSelector)([selectorTreeViewItemsState, selectorItemMeta], (itemsState, itemMeta) => {
   if (itemMeta == null) {
     return -1;
   }
-  const parentIndexes = itemsState.itemChildrenIndexesLookup[itemMeta.parentId ?? TREE_VIEW_ROOT_PARENT_ID];
+  const parentIndexes = itemsState.itemChildrenIndexesLookup[itemMeta.parentId ?? _useTreeViewItems.TREE_VIEW_ROOT_PARENT_ID];
   return parentIndexes[itemMeta.id];
 });
 
@@ -86,7 +92,7 @@ export const selectorItemIndex = createSelector([selectorTreeViewItemsState, sel
  * @param {TreeViewItemId} itemId The id of the item to get the parent id of.
  * @returns {TreeViewItemId | null} The id of the parent of the item.
  */
-export const selectorItemParentId = createSelector([selectorItemMeta], itemMeta => itemMeta?.parentId ?? null);
+const selectorItemParentId = exports.selectorItemParentId = (0, _selectors.createSelector)([selectorItemMeta], itemMeta => itemMeta?.parentId ?? null);
 
 /**
  * Get the depth of an item (items at the root level have a depth of 0).
@@ -94,8 +100,8 @@ export const selectorItemParentId = createSelector([selectorItemMeta], itemMeta
  * @param {TreeViewItemId} itemId The id of the item to get the depth of.
  * @returns {number} The depth of the item.
  */
-export const selectorItemDepth = createSelector([selectorItemMeta], itemMeta => itemMeta?.depth ?? 0);
-export const selectorCanItemBeFocused = createSelector([selectorTreeViewItemsState, selectorIsItemDisabled], (itemsState, isItemDisabled) => {
+const selectorItemDepth = exports.selectorItemDepth = (0, _selectors.createSelector)([selectorItemMeta], itemMeta => itemMeta?.depth ?? 0);
+const selectorCanItemBeFocused = exports.selectorCanItemBeFocused = (0, _selectors.createSelector)([selectorTreeViewItemsState, selectorIsItemDisabled], (itemsState, isItemDisabled) => {
   if (itemsState.disabledItemsFocusable) {
     return true;
   }

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

@@ -1,156 +1,156 @@
 import * as React from 'react';
 import { DefaultizedProps } from '@mui/x-internals/types';
-import { TreeViewItemMeta, TreeViewPluginSignature } from '../../models';
-import { TreeViewBaseItem, TreeViewDefaultItemModelProperties, TreeViewItemId } from '../../../models';
+import { TreeViewItemMeta, TreeViewPluginSignature } from "../../models/index.js";
+import { TreeViewBaseItem, TreeViewDefaultItemModelProperties, TreeViewItemId } from "../../../models/index.js";
 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 {string} 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[];
+  /**
+   * 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 {string} 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[];
 }
 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;
+  /**
+   * 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;
 }
 export interface UseTreeViewItemsParameters<R extends {
-    children?: R[];
+  children?: R[];
 }> {
+  /**
+   * If `true`, will allow focus on disabled items.
+   * @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 id of a given item.
+   *
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {string} 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 {string} itemId The id of the focused item.
+   */
+  onItemClick?: (event: React.MouseEvent, itemId: string) => void;
+  /**
+   * Horizontal indentation between an item and its children.
+   * Examples: 24, "24px", "2rem", "2em".
+   * @default 12px
+   */
+  itemChildrenIndentation?: string | number;
+}
+export type UseTreeViewItemsDefaultizedParameters<R extends {
+  children?: R[];
+}> = DefaultizedProps<UseTreeViewItemsParameters<R>, 'disabledItemsFocusable' | 'itemChildrenIndentation'>;
+interface UseTreeViewItemsEventLookup {
+  removeItem: {
+    params: {
+      id: string;
+    };
+  };
+}
+export interface UseTreeViewItemsState<R extends {}> {
+  items: {
     /**
      * If `true`, will allow focus on disabled items.
-     * @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.
+     * Always equal to `props.disabledItemsFocusable` (or `false` if not provided).
      */
-    isItemDisabled?: (item: R) => boolean;
+    disabledItemsFocusable: 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
+     * 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.
      */
-    getItemLabel?: (item: R) => string;
+    itemModelLookup: {
+      [itemId: string]: TreeViewBaseItem<R>;
+    };
     /**
-     * Used to determine the id of a given item.
-     *
-     * @template R
-     * @param {R} item The item to check.
-     * @returns {string} The id of the item.
-     * @default (item) => item.id
+     * Meta data of each item.
      */
-    getItemId?: (item: R) => TreeViewItemId;
+    itemMetaLookup: {
+      [itemId: string]: TreeViewItemMeta;
+    };
     /**
-     * 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 {string} itemId The id of the focused item.
+     * Ordered children ids of each item.
      */
-    onItemClick?: (event: React.MouseEvent, itemId: string) => void;
+    itemOrderedChildrenIdsLookup: {
+      [parentItemId: string]: string[];
+    };
     /**
-     * Horizontal indentation between an item and its children.
-     * Examples: 24, "24px", "2rem", "2em".
-     * @default 12px
+     * Index of each child in the ordered children ids of its parent.
      */
-    itemChildrenIndentation?: string | number;
-}
-export type UseTreeViewItemsDefaultizedParameters<R extends {
-    children?: R[];
-}> = DefaultizedProps<UseTreeViewItemsParameters<R>, 'disabledItemsFocusable' | 'itemChildrenIndentation'>;
-interface UseTreeViewItemsEventLookup {
-    removeItem: {
-        params: {
-            id: string;
-        };
-    };
-}
-export interface UseTreeViewItemsState<R extends {}> {
-    items: {
-        /**
-         * If `true`, will allow focus on disabled items.
-         * 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]: string[];
-        };
-        /**
-         * Index of each child in the ordered children ids of its parent.
-         */
-        itemChildrenIndexesLookup: {
-            [parentItemId: string]: {
-                [itemId: string]: number;
-            };
-        };
+    itemChildrenIndexesLookup: {
+      [parentItemId: string]: {
+        [itemId: string]: number;
+      };
     };
+  };
 }
 interface UseTreeViewItemsContextValue {
-    items: {
-        onItemClick: (event: React.MouseEvent, itemId: string) => void;
-    };
+  items: {
+    onItemClick: (event: React.MouseEvent, itemId: string) => void;
+  };
 }
 export type UseTreeViewItemsSignature = TreeViewPluginSignature<{
-    params: UseTreeViewItemsParameters<any>;
-    defaultizedParams: UseTreeViewItemsDefaultizedParameters<any>;
-    instance: UseTreeViewItemsInstance<any>;
-    publicAPI: UseTreeViewItemsPublicAPI<any>;
-    events: UseTreeViewItemsEventLookup;
-    state: UseTreeViewItemsState<TreeViewDefaultItemModelProperties>;
-    contextValue: UseTreeViewItemsContextValue;
+  params: UseTreeViewItemsParameters<any>;
+  defaultizedParams: UseTreeViewItemsDefaultizedParameters<any>;
+  instance: UseTreeViewItemsInstance<any>;
+  publicAPI: UseTreeViewItemsPublicAPI<any>;
+  events: UseTreeViewItemsEventLookup;
+  state: UseTreeViewItemsState<TreeViewDefaultItemModelProperties>;
+  contextValue: UseTreeViewItemsContextValue;
 }>;
-export {};
+export {};

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

@@ -1 +1,5 @@
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -1,4 +1,4 @@
 export declare const TREE_VIEW_ROOT_PARENT_ID = "__TREE_VIEW_ROOT_PARENT_ID__";
 export declare const buildSiblingIndexes: (siblings: string[]) => {
-    [itemId: string]: number;
-};
+  [itemId: string]: number;
+};

package/internals/plugins/useTreeViewItems/useTreeViewItems.utils.js

@@ -1,8 +1,15 @@
-export const TREE_VIEW_ROOT_PARENT_ID = '__TREE_VIEW_ROOT_PARENT_ID__';
-export const buildSiblingIndexes = siblings => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildSiblingIndexes = exports.TREE_VIEW_ROOT_PARENT_ID = void 0;
+const TREE_VIEW_ROOT_PARENT_ID = exports.TREE_VIEW_ROOT_PARENT_ID = '__TREE_VIEW_ROOT_PARENT_ID__';
+const buildSiblingIndexes = siblings => {
   const siblingsIndexLookup = {};
   siblings.forEach((childId, index) => {
     siblingsIndexLookup[childId] = index;
   });
   return siblingsIndexLookup;
-};
+};
+exports.buildSiblingIndexes = buildSiblingIndexes;

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

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

package/internals/plugins/useTreeViewJSXItems/index.js

@@ -1 +1,12 @@
-export { useTreeViewJSXItems } from "./useTreeViewJSXItems.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useTreeViewJSXItems", {
+  enumerable: true,
+  get: function () {
+    return _useTreeViewJSXItems.useTreeViewJSXItems;
+  }
+});
+var _useTreeViewJSXItems = require("./useTreeViewJSXItems");

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

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

package/internals/plugins/useTreeViewJSXItems/useTreeViewJSXItems.js

@@ -1,35 +1,43 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import useEventCallback from '@mui/utils/useEventCallback';
-import useForkRef from '@mui/utils/useForkRef';
-import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
-import { publishTreeViewEvent } from "../../utils/publishTreeViewEvent.js";
-import { useTreeViewContext } from "../../TreeViewProvider/index.js";
-import { TreeViewChildrenItemContext, TreeViewChildrenItemProvider } from "../../TreeViewProvider/TreeViewChildrenItemProvider.js";
-import { buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from "../useTreeViewItems/useTreeViewItems.utils.js";
-import { TreeViewItemDepthContext } from "../../TreeViewItemDepthContext/index.js";
-import { generateTreeItemIdAttribute } from "../../corePlugins/useTreeViewId/useTreeViewId.utils.js";
-import { isItemExpandable } from "../../../hooks/useTreeItemUtils/useTreeItemUtils.js";
-import { useSelector } from "../../hooks/useSelector.js";
-import { selectorTreeViewId } from "../../corePlugins/useTreeViewId/useTreeViewId.selectors.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-export const useTreeViewJSXItems = ({
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewJSXItems = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedEffect"));
+var _publishTreeViewEvent = require("../../utils/publishTreeViewEvent");
+var _TreeViewProvider = require("../../TreeViewProvider");
+var _TreeViewChildrenItemProvider = require("../../TreeViewProvider/TreeViewChildrenItemProvider");
+var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.utils");
+var _TreeViewItemDepthContext = require("../../TreeViewItemDepthContext");
+var _useTreeViewId = require("../../corePlugins/useTreeViewId/useTreeViewId.utils");
+var _useTreeItemUtils = require("../../../hooks/useTreeItemUtils/useTreeItemUtils");
+var _useSelector = require("../../hooks/useSelector");
+var _useTreeViewId2 = require("../../corePlugins/useTreeViewId/useTreeViewId.selectors");
+var _jsxRuntime = require("react/jsx-runtime");
+const useTreeViewJSXItems = ({
   instance,
   store
 }) => {
   instance.preventItemUpdates();
-  const insertJSXItem = useEventCallback(item => {
+  const insertJSXItem = (0, _useEventCallback.default)(item => {
     store.update(prevState => {
       if (prevState.items.itemMetaLookup[item.id] != null) {
         throw new Error(['MUI X: The Tree View component requires all items to have a unique `id` property.', 'Alternatively, you can use the `getItemId` prop to specify a custom id for each item.', `Two items were provided with the same id in the \`items\` prop: "${item.id}"`].join('\n'));
       }
-      return _extends({}, prevState, {
-        items: _extends({}, prevState.items, {
-          itemMetaLookup: _extends({}, prevState.items.itemMetaLookup, {
+      return (0, _extends2.default)({}, prevState, {
+        items: (0, _extends2.default)({}, prevState.items, {
+          itemMetaLookup: (0, _extends2.default)({}, prevState.items.itemMetaLookup, {
             [item.id]: item
           }),
           // For Simple Tree View, we don't have a proper `item` object, so we create a very basic one.
-          itemModelLookup: _extends({}, prevState.items.itemModelLookup, {
+          itemModelLookup: (0, _extends2.default)({}, prevState.items.itemModelLookup, {
             [item.id]: {
               id: item.id,
               label: item.label ?? ''
@@ -40,43 +48,43 @@ export const useTreeViewJSXItems = ({
     });
     return () => {
       store.update(prevState => {
-        const newItemMetaLookup = _extends({}, prevState.items.itemMetaLookup);
-        const newItemModelLookup = _extends({}, prevState.items.itemModelLookup);
+        const newItemMetaLookup = (0, _extends2.default)({}, prevState.items.itemMetaLookup);
+        const newItemModelLookup = (0, _extends2.default)({}, prevState.items.itemModelLookup);
         delete newItemMetaLookup[item.id];
         delete newItemModelLookup[item.id];
-        return _extends({}, prevState, {
-          items: _extends({}, prevState.items, {
+        return (0, _extends2.default)({}, prevState, {
+          items: (0, _extends2.default)({}, prevState.items, {
             itemMetaLookup: newItemMetaLookup,
             itemModelLookup: newItemModelLookup
           })
         });
       });
-      publishTreeViewEvent(instance, 'removeItem', {
+      (0, _publishTreeViewEvent.publishTreeViewEvent)(instance, 'removeItem', {
         id: item.id
       });
     };
   });
   const setJSXItemsOrderedChildrenIds = (parentId, orderedChildrenIds) => {
-    const parentIdWithDefault = parentId ?? TREE_VIEW_ROOT_PARENT_ID;
-    store.update(prevState => _extends({}, prevState, {
-      items: _extends({}, prevState.items, {
-        itemOrderedChildrenIdsLookup: _extends({}, prevState.items.itemOrderedChildrenIdsLookup, {
+    const parentIdWithDefault = parentId ?? _useTreeViewItems.TREE_VIEW_ROOT_PARENT_ID;
+    store.update(prevState => (0, _extends2.default)({}, prevState, {
+      items: (0, _extends2.default)({}, prevState.items, {
+        itemOrderedChildrenIdsLookup: (0, _extends2.default)({}, prevState.items.itemOrderedChildrenIdsLookup, {
           [parentIdWithDefault]: orderedChildrenIds
         }),
-        itemChildrenIndexesLookup: _extends({}, prevState.items.itemChildrenIndexesLookup, {
-          [parentIdWithDefault]: buildSiblingIndexes(orderedChildrenIds)
+        itemChildrenIndexesLookup: (0, _extends2.default)({}, prevState.items.itemChildrenIndexesLookup, {
+          [parentIdWithDefault]: (0, _useTreeViewItems.buildSiblingIndexes)(orderedChildrenIds)
         })
       })
     }));
   };
-  const mapFirstCharFromJSX = useEventCallback((itemId, firstChar) => {
+  const mapFirstCharFromJSX = (0, _useEventCallback.default)((itemId, firstChar) => {
     instance.updateFirstCharMap(firstCharMap => {
       firstCharMap[itemId] = firstChar;
       return firstCharMap;
     });
     return () => {
       instance.updateFirstCharMap(firstCharMap => {
-        const newMap = _extends({}, firstCharMap);
+        const newMap = (0, _extends2.default)({}, firstCharMap);
         delete newMap[itemId];
         return newMap;
       });
@@ -90,6 +98,7 @@ export const useTreeViewJSXItems = ({
     }
   };
 };
+exports.useTreeViewJSXItems = useTreeViewJSXItems;
 const useTreeViewJSXItemsItemPlugin = ({
   props,
   rootRef,
@@ -98,7 +107,7 @@ const useTreeViewJSXItemsItemPlugin = ({
   const {
     instance,
     store
-  } = useTreeViewContext();
+  } = (0, _TreeViewProvider.useTreeViewContext)();
   const {
     children,
     disabled = false,
@@ -106,7 +115,7 @@ const useTreeViewJSXItemsItemPlugin = ({
     itemId,
     id
   } = props;
-  const parentContext = React.useContext(TreeViewChildrenItemContext);
+  const parentContext = React.useContext(_TreeViewChildrenItemProvider.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'));
   }
@@ -115,14 +124,14 @@ const useTreeViewJSXItemsItemPlugin = ({
     unregisterChild,
     parentId
   } = parentContext;
-  const expandable = isItemExpandable(children);
+  const expandable = (0, _useTreeItemUtils.isItemExpandable)(children);
   const pluginContentRef = React.useRef(null);
-  const handleContentRef = useForkRef(pluginContentRef, contentRef);
-  const treeId = useSelector(store, selectorTreeViewId);
+  const handleContentRef = (0, _useForkRef.default)(pluginContentRef, contentRef);
+  const treeId = (0, _useSelector.useSelector)(store, _useTreeViewId2.selectorTreeViewId);
 
   // Prevent any flashing
-  useEnhancedEffect(() => {
-    const idAttribute = generateTreeItemIdAttribute({
+  (0, _useEnhancedEffect.default)(() => {
+    const idAttribute = (0, _useTreeViewId.generateTreeItemIdAttribute)({
       itemId,
       treeId,
       id
@@ -133,7 +142,7 @@ const useTreeViewJSXItemsItemPlugin = ({
       unregisterChild(idAttribute);
     };
   }, [store, instance, registerChild, unregisterChild, itemId, id, treeId]);
-  useEnhancedEffect(() => {
+  (0, _useEnhancedEffect.default)(() => {
     return instance.insertJSXItem({
       id: itemId,
       idAttribute: id,
@@ -160,11 +169,11 @@ useTreeViewJSXItems.wrapItem = ({
   idAttribute
 }) => {
   // eslint-disable-next-line react-hooks/rules-of-hooks
-  const depthContext = React.useContext(TreeViewItemDepthContext);
-  return /*#__PURE__*/_jsx(TreeViewChildrenItemProvider, {
+  const depthContext = React.useContext(_TreeViewItemDepthContext.TreeViewItemDepthContext);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_TreeViewChildrenItemProvider.TreeViewChildrenItemProvider, {
     itemId: itemId,
     idAttribute: idAttribute,
-    children: /*#__PURE__*/_jsx(TreeViewItemDepthContext.Provider, {
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_TreeViewItemDepthContext.TreeViewItemDepthContext.Provider, {
       value: depthContext + 1,
       children: children
     })
@@ -172,10 +181,10 @@ useTreeViewJSXItems.wrapItem = ({
 };
 useTreeViewJSXItems.wrapRoot = ({
   children
-}) => /*#__PURE__*/_jsx(TreeViewChildrenItemProvider, {
+}) => /*#__PURE__*/(0, _jsxRuntime.jsx)(_TreeViewChildrenItemProvider.TreeViewChildrenItemProvider, {
   itemId: null,
   idAttribute: null,
-  children: /*#__PURE__*/_jsx(TreeViewItemDepthContext.Provider, {
+  children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_TreeViewItemDepthContext.TreeViewItemDepthContext.Provider, {
     value: 0,
     children: children
   })