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

package/{node → esm}/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js

@@ -1,36 +1,28 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTreeViewKeyboardNavigation = void 0;
-var React = _interopRequireWildcard(require("react"));
-var _RtlProvider = require("@mui/system/RtlProvider");
-var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
-var _tree = require("../../utils/tree");
-var _plugins = require("../../utils/plugins");
-var _useTreeViewLabel = require("../useTreeViewLabel");
-var _useSelector = require("../../hooks/useSelector");
-var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
-var _useTreeViewLabel2 = require("../useTreeViewLabel/useTreeViewLabel.selectors");
-var _useTreeViewSelection = require("../useTreeViewSelection/useTreeViewSelection.selectors");
-var _useTreeViewExpansion = require("../useTreeViewExpansion/useTreeViewExpansion.selectors");
+import * as React from 'react';
+import { useRtl } from '@mui/system/RtlProvider';
+import useEventCallback from '@mui/utils/useEventCallback';
+import { getFirstNavigableItem, getLastNavigableItem, getNextNavigableItem, getPreviousNavigableItem, isTargetInDescendants } from "../../utils/tree.js";
+import { hasPlugin } from "../../utils/plugins.js";
+import { useTreeViewLabel } from "../useTreeViewLabel/index.js";
+import { useSelector } from "../../hooks/useSelector.js";
+import { selectorItemMetaLookup, selectorIsItemDisabled, selectorItemParentId } from "../useTreeViewItems/useTreeViewItems.selectors.js";
+import { selectorIsItemBeingEdited, selectorIsItemEditable } from "../useTreeViewLabel/useTreeViewLabel.selectors.js";
+import { selectorIsItemSelected, selectorIsMultiSelectEnabled, selectorIsSelectionEnabled } from "../useTreeViewSelection/useTreeViewSelection.selectors.js";
+import { selectorIsItemExpandable, selectorIsItemExpanded } from "../useTreeViewExpansion/useTreeViewExpansion.selectors.js";
 function isPrintableKey(string) {
   return !!string && string.length === 1 && !!string.match(/\S/);
 }
-const useTreeViewKeyboardNavigation = ({
+export const useTreeViewKeyboardNavigation = ({
   instance,
   store,
   params
 }) => {
-  const isRtl = (0, _RtlProvider.useRtl)();
+  const isRtl = useRtl();
   const firstCharMap = React.useRef({});
-  const updateFirstCharMap = (0, _useEventCallback.default)(callback => {
+  const updateFirstCharMap = useEventCallback(callback => {
     firstCharMap.current = callback(firstCharMap.current);
   });
-  const itemMetaLookup = (0, _useSelector.useSelector)(store, _useTreeViewItems.selectorItemMetaLookup);
+  const itemMetaLookup = useSelector(store, selectorItemMetaLookup);
   React.useEffect(() => {
     if (instance.areItemUpdatesPrevented()) {
       return;
@@ -45,10 +37,10 @@ const useTreeViewKeyboardNavigation = ({
   const getFirstMatchingItem = (itemId, query) => {
     const cleanQuery = query.toLowerCase();
     const getNextItem = itemIdToCheck => {
-      const nextItemId = (0, _tree.getNextNavigableItem)(store.value, itemIdToCheck);
+      const nextItemId = getNextNavigableItem(store.value, itemIdToCheck);
       // We reached the end of the tree, check from the beginning
       if (nextItemId === null) {
-        return (0, _tree.getFirstNavigableItem)(store.value);
+        return getFirstNavigableItem(store.value);
       }
       return nextItemId;
     };
@@ -66,21 +58,22 @@ const useTreeViewKeyboardNavigation = ({
     }
     return matchingItemId;
   };
-  const canToggleItemSelection = itemId => !params.disableSelection && !(0, _useTreeViewItems.selectorIsItemDisabled)(store.value, itemId);
+  const canToggleItemSelection = itemId => selectorIsSelectionEnabled(store.value) && !selectorIsItemDisabled(store.value, itemId);
   const canToggleItemExpansion = itemId => {
-    return !(0, _useTreeViewItems.selectorIsItemDisabled)(store.value, itemId) && (0, _useTreeViewExpansion.selectorIsItemExpandable)(store.value, itemId);
+    return !selectorIsItemDisabled(store.value, itemId) && selectorIsItemExpandable(store.value, itemId);
   };
 
   // ARIA specification: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/#keyboardinteraction
-  const handleItemKeyDown = (event, itemId) => {
+  const handleItemKeyDown = async (event, itemId) => {
     if (event.defaultMuiPrevented) {
       return;
     }
-    if (event.altKey || (0, _tree.isTargetInDescendants)(event.target, event.currentTarget)) {
+    if (event.altKey || isTargetInDescendants(event.target, event.currentTarget)) {
       return;
     }
     const ctrlPressed = event.ctrlKey || event.metaKey;
     const key = event.key;
+    const isMultiSelectEnabled = selectorIsMultiSelectEnabled(store.value);
 
     // eslint-disable-next-line default-case
     switch (true) {
@@ -88,14 +81,14 @@ const useTreeViewKeyboardNavigation = ({
       case key === ' ' && canToggleItemSelection(itemId):
         {
           event.preventDefault();
-          if (params.multiSelect && event.shiftKey) {
+          if (isMultiSelectEnabled && event.shiftKey) {
             instance.expandSelectionRange(event, itemId);
           } else {
-            instance.selectItem({
+            instance.setItemSelection({
               event,
               itemId,
-              keepExistingSelection: params.multiSelect,
-              shouldBeSelected: params.multiSelect ? undefined : true
+              keepExistingSelection: isMultiSelectEnabled,
+              shouldBeSelected: undefined
             });
           }
           break;
@@ -105,24 +98,24 @@ const useTreeViewKeyboardNavigation = ({
       // If the focused item has no children, we select it.
       case key === 'Enter':
         {
-          if ((0, _plugins.hasPlugin)(instance, _useTreeViewLabel.useTreeViewLabel) && (0, _useTreeViewLabel2.selectorIsItemEditable)(store.value, {
-            itemId,
-            isItemEditable: params.isItemEditable
-          }) && !(0, _useTreeViewLabel2.selectorIsItemBeingEdited)(store.value, itemId)) {
+          if (hasPlugin(instance, useTreeViewLabel) && selectorIsItemEditable(store.value, itemId) && !selectorIsItemBeingEdited(store.value, itemId)) {
             instance.setEditedItemId(itemId);
           } else if (canToggleItemExpansion(itemId)) {
-            instance.toggleItemExpansion(event, itemId);
+            instance.setItemExpansion({
+              event,
+              itemId
+            });
             event.preventDefault();
           } else if (canToggleItemSelection(itemId)) {
-            if (params.multiSelect) {
+            if (isMultiSelectEnabled) {
               event.preventDefault();
-              instance.selectItem({
+              instance.setItemSelection({
                 event,
                 itemId,
                 keepExistingSelection: true
               });
-            } else if (!(0, _useTreeViewSelection.selectorIsItemSelected)(store.value, itemId)) {
-              instance.selectItem({
+            } else if (!selectorIsItemSelected(store.value, itemId)) {
+              instance.setItemSelection({
                 event,
                 itemId
               });
@@ -135,14 +128,14 @@ const useTreeViewKeyboardNavigation = ({
       // Focus the next focusable item
       case key === 'ArrowDown':
         {
-          const nextItem = (0, _tree.getNextNavigableItem)(store.value, itemId);
+          const nextItem = getNextNavigableItem(store.value, itemId);
           if (nextItem) {
             event.preventDefault();
             instance.focusItem(event, nextItem);
 
             // Multi select behavior when pressing Shift + ArrowDown
             // Toggles the selection state of the next item
-            if (params.multiSelect && event.shiftKey && canToggleItemSelection(nextItem)) {
+            if (isMultiSelectEnabled && event.shiftKey && canToggleItemSelection(nextItem)) {
               instance.selectItemFromArrowNavigation(event, itemId, nextItem);
             }
           }
@@ -152,14 +145,14 @@ const useTreeViewKeyboardNavigation = ({
       // Focuses the previous focusable item
       case key === 'ArrowUp':
         {
-          const previousItem = (0, _tree.getPreviousNavigableItem)(store.value, itemId);
+          const previousItem = getPreviousNavigableItem(store.value, itemId);
           if (previousItem) {
             event.preventDefault();
             instance.focusItem(event, previousItem);
 
             // Multi select behavior when pressing Shift + ArrowUp
             // Toggles the selection state of the previous item
-            if (params.multiSelect && event.shiftKey && canToggleItemSelection(previousItem)) {
+            if (isMultiSelectEnabled && event.shiftKey && canToggleItemSelection(previousItem)) {
               instance.selectItemFromArrowNavigation(event, itemId, previousItem);
             }
           }
@@ -173,14 +166,17 @@ const useTreeViewKeyboardNavigation = ({
           if (ctrlPressed) {
             return;
           }
-          if ((0, _useTreeViewExpansion.selectorIsItemExpanded)(store.value, itemId)) {
-            const nextItemId = (0, _tree.getNextNavigableItem)(store.value, itemId);
+          if (selectorIsItemExpanded(store.value, itemId)) {
+            const nextItemId = getNextNavigableItem(store.value, itemId);
             if (nextItemId) {
               instance.focusItem(event, nextItemId);
               event.preventDefault();
             }
           } else if (canToggleItemExpansion(itemId)) {
-            instance.toggleItemExpansion(event, itemId);
+            instance.setItemExpansion({
+              event,
+              itemId
+            });
             event.preventDefault();
           }
           break;
@@ -193,11 +189,14 @@ const useTreeViewKeyboardNavigation = ({
           if (ctrlPressed) {
             return;
           }
-          if (canToggleItemExpansion(itemId) && (0, _useTreeViewExpansion.selectorIsItemExpanded)(store.value, itemId)) {
-            instance.toggleItemExpansion(event, itemId);
+          if (canToggleItemExpansion(itemId) && selectorIsItemExpanded(store.value, itemId)) {
+            instance.setItemExpansion({
+              event,
+              itemId
+            });
             event.preventDefault();
           } else {
-            const parent = (0, _useTreeViewItems.selectorItemParentId)(store.value, itemId);
+            const parent = selectorItemParentId(store.value, itemId);
             if (parent) {
               instance.focusItem(event, parent);
               event.preventDefault();
@@ -211,10 +210,10 @@ const useTreeViewKeyboardNavigation = ({
         {
           // Multi select behavior when pressing Ctrl + Shift + Home
           // Selects the focused item and all items up to the first item.
-          if (canToggleItemSelection(itemId) && params.multiSelect && ctrlPressed && event.shiftKey) {
+          if (canToggleItemSelection(itemId) && isMultiSelectEnabled && ctrlPressed && event.shiftKey) {
             instance.selectRangeFromStartToItem(event, itemId);
           } else {
-            instance.focusItem(event, (0, _tree.getFirstNavigableItem)(store.value));
+            instance.focusItem(event, getFirstNavigableItem(store.value));
           }
           event.preventDefault();
           break;
@@ -225,10 +224,10 @@ const useTreeViewKeyboardNavigation = ({
         {
           // Multi select behavior when pressing Ctrl + Shirt + End
           // Selects the focused item and all the items down to the last item.
-          if (canToggleItemSelection(itemId) && params.multiSelect && ctrlPressed && event.shiftKey) {
+          if (canToggleItemSelection(itemId) && isMultiSelectEnabled && ctrlPressed && event.shiftKey) {
             instance.selectRangeFromItemToEnd(event, itemId);
           } else {
-            instance.focusItem(event, (0, _tree.getLastNavigableItem)(store.value));
+            instance.focusItem(event, getLastNavigableItem(store.value));
           }
           event.preventDefault();
           break;
@@ -244,7 +243,7 @@ const useTreeViewKeyboardNavigation = ({
 
       // Multi select behavior when pressing Ctrl + a
       // Selects all the items
-      case String.fromCharCode(event.keyCode) === 'A' && ctrlPressed && params.multiSelect && !params.disableSelection:
+      case String.fromCharCode(event.keyCode) === 'A' && ctrlPressed && isMultiSelectEnabled && selectorIsSelectionEnabled(store.value):
         {
           instance.selectAllNavigableItems(event);
           event.preventDefault();
@@ -271,5 +270,4 @@ const useTreeViewKeyboardNavigation = ({
     }
   };
 };
-exports.useTreeViewKeyboardNavigation = useTreeViewKeyboardNavigation;
 useTreeViewKeyboardNavigation.params = {};

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

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { TreeViewPluginSignature } from "../../models/index.js";
+import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
+import { UseTreeViewSelectionSignature } from "../useTreeViewSelection/index.js";
+import { UseTreeViewFocusSignature } from "../useTreeViewFocus/index.js";
+import { UseTreeViewExpansionSignature } from "../useTreeViewExpansion/index.js";
+import { TreeViewItemId, TreeViewCancellableEvent } from "../../../models/index.js";
+export interface UseTreeViewKeyboardNavigationInstance {
+  /**
+   * Updates the `firstCharMap` to add/remove the first character of some item's labels.
+   * This map is used to navigate the tree using type-ahead search.
+   * This method is only used by the `useTreeViewJSXItems` plugin, otherwise the updates are handled internally.
+   * @param {(map: TreeViewFirstCharMap) => TreeViewFirstCharMap} updater The function to update the map.
+   */
+  updateFirstCharMap: (updater: (map: TreeViewFirstCharMap) => TreeViewFirstCharMap) => void;
+  /**
+   * Callback fired when a key is pressed on an item.
+   * Handles all the keyboard navigation logic.
+   * @param {React.KeyboardEvent<HTMLElement> & TreeViewCancellableEvent} event The keyboard event that triggered the callback.
+   * @param {TreeViewItemId} itemId The id of the item that the event was triggered on.
+   */
+  handleItemKeyDown: (event: React.KeyboardEvent<HTMLElement> & TreeViewCancellableEvent, itemId: TreeViewItemId) => void;
+}
+export type UseTreeViewKeyboardNavigationSignature = TreeViewPluginSignature<{
+  instance: UseTreeViewKeyboardNavigationInstance;
+  dependencies: [UseTreeViewItemsSignature, UseTreeViewSelectionSignature, UseTreeViewFocusSignature, UseTreeViewExpansionSignature];
+}>;
+export type TreeViewFirstCharMap = {
+  [itemId: string]: string;
+};

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

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

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

@@ -0,0 +1,2 @@
+export { useTreeViewLabel } from "./useTreeViewLabel.js";
+export type { UseTreeViewLabelSignature, UseTreeViewLabelParameters } from './useTreeViewLabel.types';

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

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

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

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

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

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

package/{node → esm}/internals/plugins/useTreeViewLabel/useTreeViewLabel.itemPlugin.js

@@ -1,45 +1,35 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTreeViewLabelItemPlugin = void 0;
-var React = _interopRequireWildcard(require("react"));
-var _TreeViewProvider = require("../../TreeViewProvider");
-var _useSelector = require("../../hooks/useSelector");
-var _useTreeViewLabel = require("./useTreeViewLabel.selectors");
-const useTreeViewLabelItemPlugin = ({
+import * as React from 'react';
+import { useTreeViewContext } from "../../TreeViewProvider/index.js";
+import { useSelector } from "../../hooks/useSelector.js";
+import { selectorIsItemBeingEdited, selectorIsItemEditable } from "./useTreeViewLabel.selectors.js";
+export const useTreeViewLabelItemPlugin = ({
   props
 }) => {
   const {
-    store,
-    label: {
-      isItemEditable
-    }
-  } = (0, _TreeViewProvider.useTreeViewContext)();
+    store
+  } = useTreeViewContext();
   const {
     label,
     itemId
   } = props;
   const [labelInputValue, setLabelInputValue] = React.useState(label);
-  const editable = (0, _useSelector.useSelector)(store, _useTreeViewLabel.selectorIsItemEditable, {
-    itemId,
-    isItemEditable
-  });
-  const editing = (0, _useSelector.useSelector)(store, _useTreeViewLabel.selectorIsItemBeingEdited, itemId);
+  const isItemEditable = useSelector(store, selectorIsItemEditable, itemId);
+  const isItemBeingEdited = useSelector(store, selectorIsItemBeingEdited, itemId);
   React.useEffect(() => {
-    if (!editing) {
+    if (!isItemBeingEdited) {
       setLabelInputValue(label);
     }
-  }, [editing, label]);
+  }, [isItemBeingEdited, label]);
   return {
     propsEnhancers: {
+      label: () => ({
+        editable: isItemEditable
+      }),
       labelInput: ({
         externalEventHandlers,
         interactions
       }) => {
-        if (!editable) {
+        if (!isItemEditable) {
           return {};
         }
         const handleKeydown = event => {
@@ -79,5 +69,4 @@ const useTreeViewLabelItemPlugin = ({
       }
     }
   };
-};
-exports.useTreeViewLabelItemPlugin = useTreeViewLabelItemPlugin;
+};

package/esm/internals/plugins/useTreeViewLabel/useTreeViewLabel.js

@@ -0,0 +1,73 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import { useTreeViewLabelItemPlugin } from "./useTreeViewLabel.itemPlugin.js";
+export const useTreeViewLabel = ({
+  store,
+  params
+}) => {
+  const setEditedItemId = editedItemId => {
+    store.update(prevState => _extends({}, prevState, {
+      label: _extends({}, prevState.label, {
+        editedItemId
+      })
+    }));
+  };
+  const updateItemLabel = (itemId, label) => {
+    if (!label) {
+      throw new Error(['MUI X: The Tree View component requires all items to have a `label` property.', 'The label of an item cannot be empty.', itemId].join('\n'));
+    }
+    store.update(prevState => {
+      const item = prevState.items.itemMetaLookup[itemId];
+      if (item.label !== label) {
+        return _extends({}, prevState, {
+          items: _extends({}, prevState.items, {
+            itemMetaLookup: _extends({}, prevState.items.itemMetaLookup, {
+              [itemId]: _extends({}, item, {
+                label
+              })
+            })
+          })
+        });
+      }
+      return prevState;
+    });
+    if (params.onItemLabelChange) {
+      params.onItemLabelChange(itemId, label);
+    }
+  };
+  useEnhancedEffect(() => {
+    const isItemEditable = params.isItemEditable;
+    store.update(prevState => _extends({}, prevState, {
+      label: _extends({}, prevState.label, {
+        isItemEditable: typeof isItemEditable === 'boolean' ? () => isItemEditable : isItemEditable
+      })
+    }));
+  }, [store, params.isItemEditable]);
+  return {
+    instance: {
+      setEditedItemId,
+      updateItemLabel
+    },
+    publicAPI: {
+      updateItemLabel
+    }
+  };
+};
+useTreeViewLabel.itemPlugin = useTreeViewLabelItemPlugin;
+useTreeViewLabel.getDefaultizedParams = ({
+  params
+}) => _extends({}, params, {
+  isItemEditable: params.isItemEditable ?? false
+});
+useTreeViewLabel.getInitialState = ({
+  isItemEditable
+}) => ({
+  label: {
+    isItemEditable: typeof isItemEditable === 'boolean' ? () => isItemEditable : isItemEditable,
+    editedItemId: null
+  }
+});
+useTreeViewLabel.params = {
+  onItemLabelChange: true,
+  isItemEditable: true
+};

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

@@ -0,0 +1,68 @@
+import { UseTreeViewLabelSignature } from "./useTreeViewLabel.types.js";
+import { TreeViewRootSelector } from "../../utils/selectors.js";
+/**
+ * Check if an item is editable.
+ * @param {TreeViewState<[UseTreeViewItemsSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to check.
+ * @returns {boolean} `true` if the item is editable, `false` otherwise.
+ */
+export declare const selectorIsItemEditable: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    isItemEditable: (item: any) => boolean;
+    editedItemId: string | null;
+  } | undefined, resultFuncArgs_1: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    isItemEditable: (item: any) => boolean;
+    editedItemId: string | null;
+  } | undefined, resultFuncArgs_1: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelector<UseTreeViewLabelSignature, true>, (state: any, itemId: string) => import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if an item is being edited.
+ * @param {TreeViewState<[UseTreeViewLabelSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to check.
+ * @returns {boolean} `true` if the item is being edited, `false` otherwise.
+ */
+export declare const selectorIsItemBeingEdited: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    isItemEditable: (item: any) => boolean;
+    editedItemId: string | null;
+  } | undefined, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    isItemEditable: (item: any) => boolean;
+    editedItemId: string | null;
+  } | undefined, resultFuncArgs_1: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelector<UseTreeViewLabelSignature, true>, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -0,0 +1,24 @@
+import { createSelector } from "../../utils/selectors.js";
+import { selectorItemModel } from "../useTreeViewItems/useTreeViewItems.selectors.js";
+const selectorTreeViewLabelState = state => state.label;
+
+/**
+ * Check if an item is editable.
+ * @param {TreeViewState<[UseTreeViewItemsSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to check.
+ * @returns {boolean} `true` if the item is editable, `false` otherwise.
+ */
+export const selectorIsItemEditable = createSelector([selectorTreeViewLabelState, (state, itemId) => selectorItemModel(state, itemId)], (labelState, itemModel) => {
+  if (!itemModel || !labelState) {
+    return false;
+  }
+  return labelState.isItemEditable(itemModel);
+});
+
+/**
+ * Check if an item is being edited.
+ * @param {TreeViewState<[UseTreeViewLabelSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to check.
+ * @returns {boolean} `true` if the item is being edited, `false` otherwise.
+ */
+export const selectorIsItemBeingEdited = createSelector([selectorTreeViewLabelState, (_, itemId) => itemId], (labelState, itemId) => labelState?.editedItemId === itemId);

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

@@ -0,0 +1,60 @@
+import { DefaultizedProps } from '@mui/x-internals/types';
+import { TreeViewPluginSignature } from "../../models/index.js";
+import { TreeViewItemId } from "../../../models/index.js";
+import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
+import { TreeItemLabelInputProps } from "../../../TreeItemLabelInput/index.js";
+export interface UseTreeViewLabelPublicAPI {
+  /**
+   * Used to update the label of an item.
+   * @param {TreeViewItemId} itemId The id of the item to update the label of.
+   * @param {string} newLabel The new label of the item.
+   */
+  updateItemLabel: (itemId: TreeViewItemId, newLabel: string) => void;
+}
+export interface UseTreeViewLabelInstance extends UseTreeViewLabelPublicAPI {
+  /**
+   * Updates which item is currently being edited.
+   * @param {TreeViewItemId} itemId The id of the item that is currently being edited.
+   * @returns {void}.
+   */
+  setEditedItemId: (itemId: TreeViewItemId | null) => void;
+}
+export interface UseTreeViewLabelParameters<R extends {}> {
+  /**
+   * Callback fired when the label of an item changes.
+   * @param {TreeViewItemId} itemId The id of the item that was edited.
+   * @param {string} newLabel The new label of the items.
+   */
+  onItemLabelChange?: (itemId: TreeViewItemId, newLabel: string) => void;
+  /**
+   * Determine if a given item can be edited.
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {boolean} `true` if the item can be edited.
+   * @default () => false
+   */
+  isItemEditable?: boolean | ((item: R) => boolean);
+}
+export type UseTreeViewLabelDefaultizedParameters<R extends {}> = DefaultizedProps<UseTreeViewLabelParameters<R>, 'isItemEditable'>;
+export interface UseTreeViewLabelState {
+  label: {
+    isItemEditable: (item: any) => boolean;
+    editedItemId: string | null;
+  };
+}
+export type UseTreeViewLabelSignature = TreeViewPluginSignature<{
+  params: UseTreeViewLabelParameters<any>;
+  defaultizedParams: UseTreeViewLabelDefaultizedParameters<any>;
+  publicAPI: UseTreeViewLabelPublicAPI;
+  instance: UseTreeViewLabelInstance;
+  state: UseTreeViewLabelState;
+  dependencies: [UseTreeViewItemsSignature];
+}>;
+export interface UseTreeItemLabelInputSlotPropsFromLabelEditing extends TreeItemLabelInputProps {}
+export interface UseTreeItemLabelSlotPropsFromLabelEditing {
+  editable?: boolean;
+}
+declare module '@mui/x-tree-view/useTreeItem' {
+  interface UseTreeItemLabelInputSlotOwnProps extends UseTreeItemLabelInputSlotPropsFromLabelEditing {}
+  interface UseTreeItemLabelSlotOwnProps extends UseTreeItemLabelSlotPropsFromLabelEditing {}
+}

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

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

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

@@ -0,0 +1 @@
+export type { UseTreeViewLazyLoadingSignature, UseTreeViewLazyLoadingParameters } from './useTreeViewLazyLoading.types';

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

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