@mui/x-tree-view 8.0.0-alpha.9 → 8.0.0-beta.1

package/hooks/useTreeItemUtils/index.js

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

package/hooks/useTreeItemUtils/useTreeItemUtils.d.ts

@@ -1,43 +1,42 @@
 import * as React from 'react';
+import type { UseTreeViewLazyLoadingSignature } from '../../internals/plugins/useTreeViewLazyLoading';
 import type { UseTreeViewSelectionSignature } from '../../internals/plugins/useTreeViewSelection';
 import type { UseTreeViewExpansionSignature } from '../../internals/plugins/useTreeViewExpansion';
 import type { UseTreeViewItemsSignature } from '../../internals/plugins/useTreeViewItems';
 import type { UseTreeViewFocusSignature } from '../../internals/plugins/useTreeViewFocus';
-import { UseTreeViewLabelSignature } from '../../internals/plugins/useTreeViewLabel';
+import { UseTreeViewLabelSignature } from "../../internals/plugins/useTreeViewLabel/index.js";
 import type { UseTreeItemStatus } from '../../useTreeItem';
-import { TreeViewPublicAPI } from '../../internals/models';
+import { TreeViewPublicAPI } from "../../internals/models/index.js";
 export interface UseTreeItemInteractions {
-    handleExpansion: (event: React.MouseEvent) => void;
-    handleSelection: (event: React.MouseEvent) => void;
-    handleCheckboxSelection: (event: React.ChangeEvent<HTMLInputElement>) => void;
-    toggleItemEditing: () => void;
-    handleSaveItemLabel: (event: React.SyntheticEvent, label: string) => void;
-    handleCancelItemLabelEditing: (event: React.SyntheticEvent) => void;
+  handleExpansion: (event: React.MouseEvent) => void;
+  handleSelection: (event: React.MouseEvent) => void;
+  handleCheckboxSelection: (event: React.ChangeEvent<HTMLInputElement>) => void;
+  toggleItemEditing: () => void;
+  handleSaveItemLabel: (event: React.SyntheticEvent, label: string) => void;
+  handleCancelItemLabelEditing: (event: React.SyntheticEvent) => void;
 }
 /**
  * Plugins that need to be present in the Tree View in order for `useTreeItemUtils` to work correctly.
  */
-type UseTreeItemUtilsMinimalPlugins = readonly [
-    UseTreeViewSelectionSignature,
-    UseTreeViewExpansionSignature,
-    UseTreeViewItemsSignature,
-    UseTreeViewFocusSignature
-];
+type UseTreeItemUtilsMinimalPlugins = readonly [UseTreeViewSelectionSignature, UseTreeViewExpansionSignature, UseTreeViewItemsSignature, UseTreeViewFocusSignature];
 /**
  * Plugins that `useTreeItemUtils` can use if they are present, but are not required.
  */
-export type UseTreeItemUtilsOptionalPlugins = readonly [UseTreeViewLabelSignature];
+export type UseTreeItemUtilsOptionalPlugins = readonly [UseTreeViewLabelSignature, UseTreeViewLazyLoadingSignature];
 interface UseTreeItemUtilsReturnValue<TSignatures extends UseTreeItemUtilsMinimalPlugins, TOptionalSignatures extends UseTreeItemUtilsOptionalPlugins> {
-    interactions: UseTreeItemInteractions;
-    status: UseTreeItemStatus;
-    /**
-     * The object the allows Tree View manipulation.
-     */
-    publicAPI: TreeViewPublicAPI<TSignatures, TOptionalSignatures>;
+  interactions: UseTreeItemInteractions;
+  status: UseTreeItemStatus;
+  /**
+   * The object the allows Tree View manipulation.
+   */
+  publicAPI: TreeViewPublicAPI<TSignatures, TOptionalSignatures>;
 }
-export declare const isItemExpandable: (reactChildren: React.ReactNode) => boolean;
-export declare const useTreeItemUtils: <TSignatures extends UseTreeItemUtilsMinimalPlugins = UseTreeItemUtilsMinimalPlugins, TOptionalSignatures extends UseTreeItemUtilsOptionalPlugins = UseTreeItemUtilsOptionalPlugins>({ itemId, children, }: {
-    itemId: string;
-    children?: React.ReactNode;
+export declare const itemHasChildren: (reactChildren: React.ReactNode) => boolean;
+export declare const useTreeItemUtils: <TSignatures extends UseTreeItemUtilsMinimalPlugins = UseTreeItemUtilsMinimalPlugins, TOptionalSignatures extends UseTreeItemUtilsOptionalPlugins = UseTreeItemUtilsOptionalPlugins>({
+  itemId,
+  children
+}: {
+  itemId: string;
+  children?: React.ReactNode;
 }) => UseTreeItemUtilsReturnValue<TSignatures, TOptionalSignatures>;
-export {};
+export {};

package/hooks/useTreeItemUtils/useTreeItemUtils.js

@@ -1,15 +1,20 @@
+"use strict";
 'use client';
 
-import { useTreeViewContext } from "../../internals/TreeViewProvider/index.js";
-import { useTreeViewLabel } from "../../internals/plugins/useTreeViewLabel/index.js";
-import { hasPlugin } from "../../internals/utils/plugins.js";
-import { useSelector } from "../../internals/hooks/useSelector.js";
-import { selectorIsItemExpanded } from "../../internals/plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
-import { selectorIsItemFocused } from "../../internals/plugins/useTreeViewFocus/useTreeViewFocus.selectors.js";
-import { selectorIsItemDisabled } from "../../internals/plugins/useTreeViewItems/useTreeViewItems.selectors.js";
-import { selectorIsItemSelected } from "../../internals/plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";
-import { selectorIsItemBeingEdited, selectorIsItemEditable } from "../../internals/plugins/useTreeViewLabel/useTreeViewLabel.selectors.js";
-
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeItemUtils = exports.itemHasChildren = void 0;
+var _TreeViewProvider = require("../../internals/TreeViewProvider");
+var _useTreeViewLabel = require("../../internals/plugins/useTreeViewLabel");
+var _plugins = require("../../internals/utils/plugins");
+var _useSelector = require("../../internals/hooks/useSelector");
+var _useTreeViewExpansion = require("../../internals/plugins/useTreeViewExpansion/useTreeViewExpansion.selectors");
+var _useTreeViewFocus = require("../../internals/plugins/useTreeViewFocus/useTreeViewFocus.selectors");
+var _useTreeViewItems = require("../../internals/plugins/useTreeViewItems/useTreeViewItems.selectors");
+var _useTreeViewSelection = require("../../internals/plugins/useTreeViewSelection/useTreeViewSelection.selectors");
+var _useTreeViewLazyLoading = require("../../internals/plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.selectors");
+var _useTreeViewLabel2 = require("../../internals/plugins/useTreeViewLabel/useTreeViewLabel.selectors");
 /**
  * Plugins that need to be present in the Tree View in order for `useTreeItemUtils` to work correctly.
  */
@@ -18,42 +23,44 @@ import { selectorIsItemBeingEdited, selectorIsItemEditable } from "../../interna
  * Plugins that `useTreeItemUtils` can use if they are present, but are not required.
  */
 
-export const isItemExpandable = reactChildren => {
+const itemHasChildren = reactChildren => {
   if (Array.isArray(reactChildren)) {
-    return reactChildren.length > 0 && reactChildren.some(isItemExpandable);
+    return reactChildren.length > 0 && reactChildren.some(itemHasChildren);
   }
   return Boolean(reactChildren);
 };
-export const useTreeItemUtils = ({
+exports.itemHasChildren = itemHasChildren;
+const useTreeItemUtils = ({
   itemId,
   children
 }) => {
   const {
     instance,
-    label,
     store,
-    selection: {
-      multiSelect
-    },
     publicAPI
-  } = useTreeViewContext();
-  const isExpanded = useSelector(store, selectorIsItemExpanded, itemId);
-  const isFocused = useSelector(store, selectorIsItemFocused, itemId);
-  const isSelected = useSelector(store, selectorIsItemSelected, itemId);
-  const isDisabled = useSelector(store, selectorIsItemDisabled, itemId);
-  const isEditing = useSelector(store, state => label == null ? false : selectorIsItemBeingEdited(state, itemId));
-  const isEditable = useSelector(store, state => label == null ? false : selectorIsItemEditable(state, {
-    itemId,
-    isItemEditable: label.isItemEditable
-  }));
+  } = (0, _TreeViewProvider.useTreeViewContext)();
+  const isItemExpandable = (0, _useSelector.useSelector)(store, _useTreeViewExpansion.selectorIsItemExpandable, itemId);
+  const isLazyLoadingEnabled = (0, _useSelector.useSelector)(store, _useTreeViewLazyLoading.selectorIsLazyLoadingEnabled);
+  const isMultiSelectEnabled = (0, _useSelector.useSelector)(store, _useTreeViewSelection.selectorIsMultiSelectEnabled);
+  const loading = (0, _useSelector.useSelector)(store, state => isLazyLoadingEnabled ? (0, _useTreeViewLazyLoading.selectorIsItemLoading)(state, itemId) : false);
+  const error = (0, _useSelector.useSelector)(store, state => isLazyLoadingEnabled ? Boolean((0, _useTreeViewLazyLoading.selectorGetTreeItemError)(state, itemId)) : false);
+  const isExpandable = itemHasChildren(children) || isItemExpandable;
+  const isExpanded = (0, _useSelector.useSelector)(store, _useTreeViewExpansion.selectorIsItemExpanded, itemId);
+  const isFocused = (0, _useSelector.useSelector)(store, _useTreeViewFocus.selectorIsItemFocused, itemId);
+  const isSelected = (0, _useSelector.useSelector)(store, _useTreeViewSelection.selectorIsItemSelected, itemId);
+  const isDisabled = (0, _useSelector.useSelector)(store, _useTreeViewItems.selectorIsItemDisabled, itemId);
+  const isEditing = (0, _useSelector.useSelector)(store, _useTreeViewLabel2.selectorIsItemBeingEdited, itemId);
+  const isEditable = (0, _useSelector.useSelector)(store, _useTreeViewLabel2.selectorIsItemEditable, itemId);
   const status = {
-    expandable: isItemExpandable(children),
+    expandable: isExpandable,
     expanded: isExpanded,
     focused: isFocused,
     selected: isSelected,
     disabled: isDisabled,
     editing: isEditing,
-    editable: isEditable
+    editable: isEditable,
+    loading,
+    error
   };
   const handleExpansion = event => {
     if (status.disabled) {
@@ -62,11 +69,15 @@ export const useTreeItemUtils = ({
     if (!status.focused) {
       instance.focusItem(event, itemId);
     }
-    const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
+    const multiple = isMultiSelectEnabled && (event.shiftKey || event.ctrlKey || event.metaKey);
 
     // If already expanded and trying to toggle selection don't close
-    if (status.expandable && !(multiple && selectorIsItemExpanded(store.value, itemId))) {
-      instance.toggleItemExpansion(event, itemId);
+    if (status.expandable && !(multiple && (0, _useTreeViewExpansion.selectorIsItemExpanded)(store.value, itemId))) {
+      // make sure the children selection is propagated again
+      instance.setItemExpansion({
+        event,
+        itemId
+      });
     }
   };
   const handleSelection = event => {
@@ -76,19 +87,19 @@ export const useTreeItemUtils = ({
     if (!status.focused) {
       instance.focusItem(event, itemId);
     }
-    const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
+    const multiple = isMultiSelectEnabled && (event.shiftKey || event.ctrlKey || event.metaKey);
     if (multiple) {
       if (event.shiftKey) {
         instance.expandSelectionRange(event, itemId);
       } else {
-        instance.selectItem({
+        instance.setItemSelection({
           event,
           itemId,
           keepExistingSelection: true
         });
       }
     } else {
-      instance.selectItem({
+      instance.setItemSelection({
         event,
         itemId,
         shouldBeSelected: true
@@ -97,19 +108,19 @@ export const useTreeItemUtils = ({
   };
   const handleCheckboxSelection = event => {
     const hasShift = event.nativeEvent.shiftKey;
-    if (multiSelect && hasShift) {
+    if (isMultiSelectEnabled && hasShift) {
       instance.expandSelectionRange(event, itemId);
     } else {
-      instance.selectItem({
+      instance.setItemSelection({
         event,
         itemId,
-        keepExistingSelection: multiSelect,
+        keepExistingSelection: isMultiSelectEnabled,
         shouldBeSelected: event.target.checked
       });
     }
   };
   const toggleItemEditing = () => {
-    if (!hasPlugin(instance, useTreeViewLabel)) {
+    if (!(0, _plugins.hasPlugin)(instance, _useTreeViewLabel.useTreeViewLabel)) {
       return;
     }
     if (isEditable) {
@@ -121,24 +132,24 @@ export const useTreeItemUtils = ({
     }
   };
   const handleSaveItemLabel = (event, newLabel) => {
-    if (!hasPlugin(instance, useTreeViewLabel)) {
+    if (!(0, _plugins.hasPlugin)(instance, _useTreeViewLabel.useTreeViewLabel)) {
       return;
     }
 
     // As a side effect of `instance.focusItem` called here and in `handleCancelItemLabelEditing` the `labelInput` is blurred
     // The `onBlur` event is triggered, which calls `handleSaveItemLabel` again.
     // To avoid creating an unwanted behavior we need to check if the item is being edited before calling `updateItemLabel`
-    if (selectorIsItemBeingEdited(store.value, itemId)) {
+    if ((0, _useTreeViewLabel2.selectorIsItemBeingEdited)(store.value, itemId)) {
       instance.updateItemLabel(itemId, newLabel);
       toggleItemEditing();
       instance.focusItem(event, itemId);
     }
   };
   const handleCancelItemLabelEditing = event => {
-    if (!hasPlugin(instance, useTreeViewLabel)) {
+    if (!(0, _plugins.hasPlugin)(instance, _useTreeViewLabel.useTreeViewLabel)) {
       return;
     }
-    if (selectorIsItemBeingEdited(store.value, itemId)) {
+    if ((0, _useTreeViewLabel2.selectorIsItemBeingEdited)(store.value, itemId)) {
       toggleItemEditing();
       instance.focusItem(event, itemId);
     }
@@ -156,4 +167,5 @@ export const useTreeItemUtils = ({
     status,
     publicAPI
   };
-};
+};
+exports.useTreeItemUtils = useTreeItemUtils;

package/hooks/useTreeViewApiRef.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
-import { TreeViewAnyPluginSignature, TreeViewPublicAPI } from '../internals/models';
-import { RichTreeViewPluginSignatures } from '../RichTreeView/RichTreeView.plugins';
+import { TreeViewAnyPluginSignature, TreeViewPublicAPI } from "../internals/models/index.js";
+import { RichTreeViewPluginSignatures } from "../RichTreeView/RichTreeView.plugins.js";
 /**
  * Hook that instantiates a [[TreeViewApiRef]].
  */
-export declare const useTreeViewApiRef: <TSignatures extends readonly TreeViewAnyPluginSignature[] = readonly [import("../internals").UseTreeViewItemsSignature, import("../internals").UseTreeViewExpansionSignature, import("../internals").UseTreeViewSelectionSignature, import("../internals").UseTreeViewFocusSignature, import("../internals").UseTreeViewKeyboardNavigationSignature, import("../internals").UseTreeViewIconsSignature, import("../internals").UseTreeViewLabelSignature]>() => React.RefObject<TreeViewPublicAPI<TSignatures> | undefined>;
+export declare const useTreeViewApiRef: <TSignatures extends readonly TreeViewAnyPluginSignature[] = RichTreeViewPluginSignatures>() => React.RefObject<TreeViewPublicAPI<TSignatures> | undefined>;

package/hooks/useTreeViewApiRef.js

@@ -1,7 +1,14 @@
+"use strict";
 'use client';
 
-import * as React from 'react';
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewApiRef = void 0;
+var React = _interopRequireWildcard(require("react"));
 /**
  * Hook that instantiates a [[TreeViewApiRef]].
  */
-export const useTreeViewApiRef = () => React.useRef(undefined);
+const useTreeViewApiRef = () => React.useRef(undefined);
+exports.useTreeViewApiRef = useTreeViewApiRef;

package/icons/icons.d.ts

@@ -1,6 +1,6 @@
 export declare const TreeViewExpandIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
-    muiName: string;
+  muiName: string;
 };
 export declare const TreeViewCollapseIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
-    muiName: string;
-};
+  muiName: string;
+};

package/icons/icons.js

@@ -1,9 +1,16 @@
-import { createSvgIcon } from '@mui/material/utils';
-import * as React from 'react';
-import { jsx as _jsx } from "react/jsx-runtime";
-export const TreeViewExpandIcon = createSvgIcon(/*#__PURE__*/_jsx("path", {
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TreeViewExpandIcon = exports.TreeViewCollapseIcon = void 0;
+var _utils = require("@mui/material/utils");
+var React = _interopRequireWildcard(require("react"));
+var _jsxRuntime = require("react/jsx-runtime");
+const TreeViewExpandIcon = exports.TreeViewExpandIcon = (0, _utils.createSvgIcon)(/*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
   d: "M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"
 }), 'TreeViewExpandIcon');
-export const TreeViewCollapseIcon = createSvgIcon(/*#__PURE__*/_jsx("path", {
+const TreeViewCollapseIcon = exports.TreeViewCollapseIcon = (0, _utils.createSvgIcon)(/*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
   d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
 }), 'TreeViewCollapseIcon');

package/icons/index.d.ts

@@ -1 +1 @@
-export * from './icons';
+export * from "./icons.js";

package/icons/index.js

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

package/index.d.ts

@@ -1,12 +1,12 @@
-export * from './SimpleTreeView';
-export * from './RichTreeView';
-export * from './TreeItem';
-export * from './useTreeItem';
-export * from './TreeItemIcon';
-export * from './TreeItemProvider';
-export * from './TreeItemDragAndDropOverlay';
-export * from './TreeItemLabelInput';
-export { unstable_resetCleanupTracking } from './internals/hooks/useInstanceEventHandler';
-export * from './models';
-export * from './icons';
-export * from './hooks';
+export * from "./SimpleTreeView/index.js";
+export * from "./RichTreeView/index.js";
+export * from "./TreeItem/index.js";
+export * from "./useTreeItem/index.js";
+export * from "./TreeItemIcon/index.js";
+export * from "./TreeItemProvider/index.js";
+export * from "./TreeItemDragAndDropOverlay/index.js";
+export * from "./TreeItemLabelInput/index.js";
+export { unstable_resetCleanupTracking } from "./internals/hooks/useInstanceEventHandler.js";
+export * from "./models/index.js";
+export * from "./icons/index.js";
+export * from "./hooks/index.js";

package/index.js

@@ -1,22 +1,154 @@
 /**
- * @mui/x-tree-view v8.0.0-alpha.9
+ * @mui/x-tree-view v8.0.0-beta.1
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-// Tree View
-export * from "./SimpleTreeView/index.js";
-export * from "./RichTreeView/index.js";
+"use strict";
 
-// Tree Item
-export * from "./TreeItem/index.js";
-export * from "./useTreeItem/index.js";
-export * from "./TreeItemIcon/index.js";
-export * from "./TreeItemProvider/index.js";
-export * from "./TreeItemDragAndDropOverlay/index.js";
-export * from "./TreeItemLabelInput/index.js";
-export { unstable_resetCleanupTracking } from "./internals/hooks/useInstanceEventHandler.js";
-export * from "./models/index.js";
-export * from "./icons/index.js";
-export * from "./hooks/index.js";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  unstable_resetCleanupTracking: true
+};
+Object.defineProperty(exports, "unstable_resetCleanupTracking", {
+  enumerable: true,
+  get: function () {
+    return _useInstanceEventHandler.unstable_resetCleanupTracking;
+  }
+});
+var _SimpleTreeView = require("./SimpleTreeView");
+Object.keys(_SimpleTreeView).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SimpleTreeView[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _SimpleTreeView[key];
+    }
+  });
+});
+var _RichTreeView = require("./RichTreeView");
+Object.keys(_RichTreeView).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _RichTreeView[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _RichTreeView[key];
+    }
+  });
+});
+var _TreeItem = require("./TreeItem");
+Object.keys(_TreeItem).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _TreeItem[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _TreeItem[key];
+    }
+  });
+});
+var _useTreeItem = require("./useTreeItem");
+Object.keys(_useTreeItem).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useTreeItem[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useTreeItem[key];
+    }
+  });
+});
+var _TreeItemIcon = require("./TreeItemIcon");
+Object.keys(_TreeItemIcon).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _TreeItemIcon[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _TreeItemIcon[key];
+    }
+  });
+});
+var _TreeItemProvider = require("./TreeItemProvider");
+Object.keys(_TreeItemProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _TreeItemProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _TreeItemProvider[key];
+    }
+  });
+});
+var _TreeItemDragAndDropOverlay = require("./TreeItemDragAndDropOverlay");
+Object.keys(_TreeItemDragAndDropOverlay).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _TreeItemDragAndDropOverlay[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _TreeItemDragAndDropOverlay[key];
+    }
+  });
+});
+var _TreeItemLabelInput = require("./TreeItemLabelInput");
+Object.keys(_TreeItemLabelInput).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _TreeItemLabelInput[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _TreeItemLabelInput[key];
+    }
+  });
+});
+var _useInstanceEventHandler = require("./internals/hooks/useInstanceEventHandler");
+var _models = require("./models");
+Object.keys(_models).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _models[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _models[key];
+    }
+  });
+});
+var _icons = require("./icons");
+Object.keys(_icons).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _icons[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _icons[key];
+    }
+  });
+});
+var _hooks = require("./hooks");
+Object.keys(_hooks).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _hooks[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _hooks[key];
+    }
+  });
+});

package/internals/TreeViewItemDepthContext/TreeViewItemDepthContext.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { TreeViewItemId } from '../../models';
-import { TreeViewState } from '../models';
+import { TreeViewItemId } from "../../models/index.js";
+import { TreeViewState } from "../models/index.js";
 import type { UseTreeViewItemsSignature } from '../plugins/useTreeViewItems';
-export declare const TreeViewItemDepthContext: React.Context<number | ((state: TreeViewState<[UseTreeViewItemsSignature]>, itemId: TreeViewItemId) => number)>;
+export declare const TreeViewItemDepthContext: React.Context<number | ((state: TreeViewState<[UseTreeViewItemsSignature]>, itemId: TreeViewItemId) => number)>;

package/internals/TreeViewItemDepthContext/TreeViewItemDepthContext.js

@@ -1,5 +1,12 @@
-import * as React from 'react';
-export const TreeViewItemDepthContext = /*#__PURE__*/React.createContext(() => -1);
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TreeViewItemDepthContext = void 0;
+var React = _interopRequireWildcard(require("react"));
+const TreeViewItemDepthContext = exports.TreeViewItemDepthContext = /*#__PURE__*/React.createContext(() => -1);
 if (process.env.NODE_ENV !== 'production') {
   TreeViewItemDepthContext.displayName = 'TreeViewItemDepthContext';
 }

package/internals/TreeViewItemDepthContext/index.d.ts

@@ -1 +1 @@
-export { TreeViewItemDepthContext } from './TreeViewItemDepthContext';
+export { TreeViewItemDepthContext } from "./TreeViewItemDepthContext.js";

package/internals/TreeViewItemDepthContext/index.js

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

package/internals/TreeViewProvider/TreeViewChildrenItemProvider.d.ts

@@ -1,17 +1,17 @@
 import * as React from 'react';
 export declare const TreeViewChildrenItemContext: React.Context<TreeViewChildrenItemContextValue | null>;
 interface TreeViewChildrenItemProviderProps {
-    itemId: string | null;
-    idAttribute: string | null;
-    children: React.ReactNode;
+  itemId: string | null;
+  idAttribute: string | null;
+  children: React.ReactNode;
 }
 export declare function TreeViewChildrenItemProvider(props: TreeViewChildrenItemProviderProps): React.JSX.Element;
 export declare namespace TreeViewChildrenItemProvider {
-    var propTypes: any;
+  var propTypes: any;
 }
 interface TreeViewChildrenItemContextValue {
-    registerChild: (idAttribute: string, itemId: string) => void;
-    unregisterChild: (idAttribute: string) => void;
-    parentId: string | null;
+  registerChild: (idAttribute: string, itemId: string) => void;
+  unregisterChild: (idAttribute: string) => void;
+  parentId: string | null;
 }
-export {};
+export {};