@mui/x-tree-view 8.0.0-beta.3 → 8.0.0

package/modern/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js

@@ -1,273 +0,0 @@
-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/);
-}
-export const useTreeViewKeyboardNavigation = ({
-  instance,
-  store,
-  params
-}) => {
-  const isRtl = useRtl();
-  const firstCharMap = React.useRef({});
-  const updateFirstCharMap = useEventCallback(callback => {
-    firstCharMap.current = callback(firstCharMap.current);
-  });
-  const itemMetaLookup = useSelector(store, selectorItemMetaLookup);
-  React.useEffect(() => {
-    if (instance.areItemUpdatesPrevented()) {
-      return;
-    }
-    const newFirstCharMap = {};
-    const processItem = item => {
-      newFirstCharMap[item.id] = item.label.substring(0, 1).toLowerCase();
-    };
-    Object.values(itemMetaLookup).forEach(processItem);
-    firstCharMap.current = newFirstCharMap;
-  }, [itemMetaLookup, params.getItemId, instance]);
-  const getFirstMatchingItem = (itemId, query) => {
-    const cleanQuery = query.toLowerCase();
-    const getNextItem = itemIdToCheck => {
-      const nextItemId = getNextNavigableItem(store.value, itemIdToCheck);
-      // We reached the end of the tree, check from the beginning
-      if (nextItemId === null) {
-        return getFirstNavigableItem(store.value);
-      }
-      return nextItemId;
-    };
-    let matchingItemId = null;
-    let currentItemId = getNextItem(itemId);
-    const checkedItems = {};
-    // The "!checkedItems[currentItemId]" condition avoids an infinite loop when there is no matching item.
-    while (matchingItemId == null && !checkedItems[currentItemId]) {
-      if (firstCharMap.current[currentItemId] === cleanQuery) {
-        matchingItemId = currentItemId;
-      } else {
-        checkedItems[currentItemId] = true;
-        currentItemId = getNextItem(currentItemId);
-      }
-    }
-    return matchingItemId;
-  };
-  const canToggleItemSelection = itemId => selectorIsSelectionEnabled(store.value) && !selectorIsItemDisabled(store.value, itemId);
-  const canToggleItemExpansion = itemId => {
-    return !selectorIsItemDisabled(store.value, itemId) && selectorIsItemExpandable(store.value, itemId);
-  };
-
-  // ARIA specification: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/#keyboardinteraction
-  const handleItemKeyDown = async (event, itemId) => {
-    if (event.defaultMuiPrevented) {
-      return;
-    }
-    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) {
-      // Select the item when pressing "Space"
-      case key === ' ' && canToggleItemSelection(itemId):
-        {
-          event.preventDefault();
-          if (isMultiSelectEnabled && event.shiftKey) {
-            instance.expandSelectionRange(event, itemId);
-          } else {
-            instance.setItemSelection({
-              event,
-              itemId,
-              keepExistingSelection: isMultiSelectEnabled,
-              shouldBeSelected: undefined
-            });
-          }
-          break;
-        }
-
-      // If the focused item has children, we expand it.
-      // If the focused item has no children, we select it.
-      case key === 'Enter':
-        {
-          if (hasPlugin(instance, useTreeViewLabel) && selectorIsItemEditable(store.value, itemId) && !selectorIsItemBeingEdited(store.value, itemId)) {
-            instance.setEditedItemId(itemId);
-          } else if (canToggleItemExpansion(itemId)) {
-            instance.setItemExpansion({
-              event,
-              itemId
-            });
-            event.preventDefault();
-          } else if (canToggleItemSelection(itemId)) {
-            if (isMultiSelectEnabled) {
-              event.preventDefault();
-              instance.setItemSelection({
-                event,
-                itemId,
-                keepExistingSelection: true
-              });
-            } else if (!selectorIsItemSelected(store.value, itemId)) {
-              instance.setItemSelection({
-                event,
-                itemId
-              });
-              event.preventDefault();
-            }
-          }
-          break;
-        }
-
-      // Focus the next focusable item
-      case key === 'ArrowDown':
-        {
-          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 (isMultiSelectEnabled && event.shiftKey && canToggleItemSelection(nextItem)) {
-              instance.selectItemFromArrowNavigation(event, itemId, nextItem);
-            }
-          }
-          break;
-        }
-
-      // Focuses the previous focusable item
-      case key === 'ArrowUp':
-        {
-          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 (isMultiSelectEnabled && event.shiftKey && canToggleItemSelection(previousItem)) {
-              instance.selectItemFromArrowNavigation(event, itemId, previousItem);
-            }
-          }
-          break;
-        }
-
-      // If the focused item is expanded, we move the focus to its first child
-      // If the focused item is collapsed and has children, we expand it
-      case key === 'ArrowRight' && !isRtl || key === 'ArrowLeft' && isRtl:
-        {
-          if (ctrlPressed) {
-            return;
-          }
-          if (selectorIsItemExpanded(store.value, itemId)) {
-            const nextItemId = getNextNavigableItem(store.value, itemId);
-            if (nextItemId) {
-              instance.focusItem(event, nextItemId);
-              event.preventDefault();
-            }
-          } else if (canToggleItemExpansion(itemId)) {
-            instance.setItemExpansion({
-              event,
-              itemId
-            });
-            event.preventDefault();
-          }
-          break;
-        }
-
-      // If the focused item is expanded, we collapse it
-      // If the focused item is collapsed and has a parent, we move the focus to this parent
-      case key === 'ArrowLeft' && !isRtl || key === 'ArrowRight' && isRtl:
-        {
-          if (ctrlPressed) {
-            return;
-          }
-          if (canToggleItemExpansion(itemId) && selectorIsItemExpanded(store.value, itemId)) {
-            instance.setItemExpansion({
-              event,
-              itemId
-            });
-            event.preventDefault();
-          } else {
-            const parent = selectorItemParentId(store.value, itemId);
-            if (parent) {
-              instance.focusItem(event, parent);
-              event.preventDefault();
-            }
-          }
-          break;
-        }
-
-      // Focuses the first item in the tree
-      case key === 'Home':
-        {
-          // Multi select behavior when pressing Ctrl + Shift + Home
-          // Selects the focused item and all items up to the first item.
-          if (canToggleItemSelection(itemId) && isMultiSelectEnabled && ctrlPressed && event.shiftKey) {
-            instance.selectRangeFromStartToItem(event, itemId);
-          } else {
-            instance.focusItem(event, getFirstNavigableItem(store.value));
-          }
-          event.preventDefault();
-          break;
-        }
-
-      // Focuses the last item in the tree
-      case key === 'End':
-        {
-          // Multi select behavior when pressing Ctrl + Shirt + End
-          // Selects the focused item and all the items down to the last item.
-          if (canToggleItemSelection(itemId) && isMultiSelectEnabled && ctrlPressed && event.shiftKey) {
-            instance.selectRangeFromItemToEnd(event, itemId);
-          } else {
-            instance.focusItem(event, getLastNavigableItem(store.value));
-          }
-          event.preventDefault();
-          break;
-        }
-
-      // Expand all siblings that are at the same level as the focused item
-      case key === '*':
-        {
-          instance.expandAllSiblings(event, itemId);
-          event.preventDefault();
-          break;
-        }
-
-      // Multi select behavior when pressing Ctrl + a
-      // Selects all the items
-      case String.fromCharCode(event.keyCode) === 'A' && ctrlPressed && isMultiSelectEnabled && selectorIsSelectionEnabled(store.value):
-        {
-          instance.selectAllNavigableItems(event);
-          event.preventDefault();
-          break;
-        }
-
-      // Type-ahead
-      // TODO: Support typing multiple characters
-      case !ctrlPressed && !event.shiftKey && isPrintableKey(key):
-        {
-          const matchingItem = getFirstMatchingItem(itemId, key);
-          if (matchingItem != null) {
-            instance.focusItem(event, matchingItem);
-            event.preventDefault();
-          }
-          break;
-        }
-    }
-  };
-  return {
-    instance: {
-      updateFirstCharMap,
-      handleItemKeyDown
-    }
-  };
-};
-useTreeViewKeyboardNavigation.params = {};

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

@@ -1,30 +0,0 @@
-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/modern/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.types.js

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

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

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

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

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

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

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

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

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

package/modern/internals/plugins/useTreeViewLabel/useTreeViewLabel.itemPlugin.js

@@ -1,72 +0,0 @@
-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
-  } = useTreeViewContext();
-  const {
-    label,
-    itemId
-  } = props;
-  const [labelInputValue, setLabelInputValue] = React.useState(label);
-  const isItemEditable = useSelector(store, selectorIsItemEditable, itemId);
-  const isItemBeingEdited = useSelector(store, selectorIsItemBeingEdited, itemId);
-  React.useEffect(() => {
-    if (!isItemBeingEdited) {
-      setLabelInputValue(label);
-    }
-  }, [isItemBeingEdited, label]);
-  return {
-    propsEnhancers: {
-      label: () => ({
-        editable: isItemEditable
-      }),
-      labelInput: ({
-        externalEventHandlers,
-        interactions
-      }) => {
-        if (!isItemEditable) {
-          return {};
-        }
-        const handleKeydown = event => {
-          externalEventHandlers.onKeyDown?.(event);
-          if (event.defaultMuiPrevented) {
-            return;
-          }
-          const target = event.target;
-          if (event.key === 'Enter' && target.value) {
-            interactions.handleSaveItemLabel(event, target.value);
-          } else if (event.key === 'Escape') {
-            interactions.handleCancelItemLabelEditing(event);
-          }
-        };
-        const handleBlur = event => {
-          externalEventHandlers.onBlur?.(event);
-          if (event.defaultMuiPrevented) {
-            return;
-          }
-          if (event.target.value) {
-            interactions.handleSaveItemLabel(event, event.target.value);
-          }
-        };
-        const handleInputChange = event => {
-          externalEventHandlers.onChange?.(event);
-          setLabelInputValue(event.target.value);
-        };
-        return {
-          value: labelInputValue ?? '',
-          'data-element': 'labelInput',
-          onChange: handleInputChange,
-          onKeyDown: handleKeydown,
-          onBlur: handleBlur,
-          autoFocus: true,
-          type: 'text'
-        };
-      }
-    }
-  };
-};

package/modern/internals/plugins/useTreeViewLabel/useTreeViewLabel.js

@@ -1,73 +0,0 @@
-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/modern/internals/plugins/useTreeViewLabel/useTreeViewLabel.selectors.d.ts

@@ -1,68 +0,0 @@
-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/modern/internals/plugins/useTreeViewLabel/useTreeViewLabel.selectors.js

@@ -1,24 +0,0 @@
-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/modern/internals/plugins/useTreeViewLabel/useTreeViewLabel.types.d.ts

@@ -1,60 +0,0 @@
-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/modern/internals/plugins/useTreeViewLabel/useTreeViewLabel.types.js

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

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

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

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

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