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

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

@@ -1,18 +1,10 @@
-"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.useTreeViewItemsReordering = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var React = _interopRequireWildcard(require("react"));
-var _internals = require("@mui/x-tree-view/internals");
-var _useTreeViewItemsReordering = require("./useTreeViewItemsReordering.utils");
-var _useTreeViewItemsReordering2 = require("./useTreeViewItemsReordering.itemPlugin");
-var _useTreeViewItemsReordering3 = require("./useTreeViewItemsReordering.selectors");
-const useTreeViewItemsReordering = ({
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { selectorItemIndex, selectorItemMeta, selectorItemOrderedChildrenIds } from '@mui/x-tree-view/internals';
+import { chooseActionToApply, isAncestor, moveItemInTree } from "./useTreeViewItemsReordering.utils.js";
+import { useTreeViewItemsReorderingItemPlugin } from "./useTreeViewItemsReordering.itemPlugin.js";
+import { selectorItemsReordering } from "./useTreeViewItemsReordering.selectors.js";
+export const useTreeViewItemsReordering = ({
   params,
   store
 }) => {
@@ -27,7 +19,7 @@ const useTreeViewItemsReordering = ({
     return true;
   }, [params.itemsReordering, params.isItemReorderable]);
   const getDroppingTargetValidActions = React.useCallback(itemId => {
-    const itemsReordering = (0, _useTreeViewItemsReordering3.selectorItemsReordering)(store.value);
+    const itemsReordering = selectorItemsReordering(store.value);
     if (!itemsReordering) {
       throw new Error('There is no ongoing reordering.');
     }
@@ -35,10 +27,10 @@ const useTreeViewItemsReordering = ({
       return {};
     }
     const canMoveItemToNewPosition = params.canMoveItemToNewPosition;
-    const targetItemMeta = (0, _internals.selectorItemMeta)(store.value, itemId);
-    const targetItemIndex = (0, _internals.selectorItemIndex)(store.value, targetItemMeta.id);
-    const draggedItemMeta = (0, _internals.selectorItemMeta)(store.value, itemsReordering.draggedItemId);
-    const draggedItemIndex = (0, _internals.selectorItemIndex)(store.value, draggedItemMeta.id);
+    const targetItemMeta = selectorItemMeta(store.value, itemId);
+    const targetItemIndex = selectorItemIndex(store.value, targetItemMeta.id);
+    const draggedItemMeta = selectorItemMeta(store.value, itemsReordering.draggedItemId);
+    const draggedItemIndex = selectorItemIndex(store.value, draggedItemMeta.id);
     const oldPosition = {
       parentId: draggedItemMeta.parentId,
       index: draggedItemIndex
@@ -74,7 +66,7 @@ const useTreeViewItemsReordering = ({
       },
       'move-to-parent': targetItemMeta.parentId == null ? null : {
         parentId: targetItemMeta.parentId,
-        index: (0, _internals.selectorItemOrderedChildrenIds)(store.value, targetItemMeta.parentId).length
+        index: selectorItemOrderedChildrenIds(store.value, targetItemMeta.parentId).length
       }
     };
     const validActions = {};
@@ -87,7 +79,7 @@ const useTreeViewItemsReordering = ({
     return validActions;
   }, [store, params.canMoveItemToNewPosition]);
   const startDraggingItem = React.useCallback(itemId => {
-    store.update(prevState => (0, _extends2.default)({}, prevState, {
+    store.update(prevState => _extends({}, prevState, {
       itemsReordering: {
         targetItemId: itemId,
         draggedItemId: itemId,
@@ -97,25 +89,25 @@ const useTreeViewItemsReordering = ({
     }));
   }, [store]);
   const stopDraggingItem = React.useCallback(itemId => {
-    const itemsReordering = (0, _useTreeViewItemsReordering3.selectorItemsReordering)(store.value);
+    const itemsReordering = selectorItemsReordering(store.value);
     if (itemsReordering == null || itemsReordering.draggedItemId !== itemId) {
       return;
     }
     if (itemsReordering.draggedItemId === itemsReordering.targetItemId || itemsReordering.action == null || itemsReordering.newPosition == null) {
-      store.update(prevState => (0, _extends2.default)({}, prevState, {
+      store.update(prevState => _extends({}, prevState, {
         itemsReordering: null
       }));
       return;
     }
-    const draggedItemMeta = (0, _internals.selectorItemMeta)(store.value, itemsReordering.draggedItemId);
+    const draggedItemMeta = selectorItemMeta(store.value, itemsReordering.draggedItemId);
     const oldPosition = {
       parentId: draggedItemMeta.parentId,
-      index: (0, _internals.selectorItemIndex)(store.value, draggedItemMeta.id)
+      index: selectorItemIndex(store.value, draggedItemMeta.id)
     };
     const newPosition = itemsReordering.newPosition;
-    store.update(prevState => (0, _extends2.default)({}, prevState, {
+    store.update(prevState => _extends({}, prevState, {
       itemsReordering: null,
-      items: (0, _useTreeViewItemsReordering.moveItemInTree)({
+      items: moveItemInTree({
         itemToMoveId: itemId,
         newPosition,
         oldPosition,
@@ -139,10 +131,10 @@ const useTreeViewItemsReordering = ({
   }) => {
     store.update(prevState => {
       const prevSubState = prevState.itemsReordering;
-      if (prevSubState == null || (0, _useTreeViewItemsReordering.isAncestor)(store, itemId, prevSubState.draggedItemId)) {
+      if (prevSubState == null || isAncestor(store, itemId, prevSubState.draggedItemId)) {
         return prevState;
       }
-      const action = (0, _useTreeViewItemsReordering.chooseActionToApply)({
+      const action = chooseActionToApply({
         itemChildrenIndentation: params.itemChildrenIndentation,
         validActions,
         targetHeight,
@@ -155,8 +147,8 @@ const useTreeViewItemsReordering = ({
       if (prevSubState.targetItemId === itemId && prevSubState.action === action && prevSubState.newPosition?.parentId === newPosition?.parentId && prevSubState.newPosition?.index === newPosition?.index) {
         return prevState;
       }
-      return (0, _extends2.default)({}, prevState, {
-        itemsReordering: (0, _extends2.default)({}, prevSubState, {
+      return _extends({}, prevState, {
+        itemsReordering: _extends({}, prevSubState, {
           targetItemId: itemId,
           newPosition,
           action
@@ -181,11 +173,10 @@ const useTreeViewItemsReordering = ({
     contextValue: pluginContextValue
   };
 };
-exports.useTreeViewItemsReordering = useTreeViewItemsReordering;
-useTreeViewItemsReordering.itemPlugin = _useTreeViewItemsReordering2.useTreeViewItemsReorderingItemPlugin;
+useTreeViewItemsReordering.itemPlugin = useTreeViewItemsReorderingItemPlugin;
 useTreeViewItemsReordering.getDefaultizedParams = ({
   params
-}) => (0, _extends2.default)({}, params, {
+}) => _extends({}, params, {
   itemsReordering: params.itemsReordering ?? false
 });
 useTreeViewItemsReordering.getInitialState = () => ({

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

@@ -0,0 +1,179 @@
+import { TreeViewState } from '@mui/x-tree-view/internals';
+import { UseTreeViewItemsReorderingSignature } from "./useTreeViewItemsReordering.types.js";
+/**
+ * Get the items reordering state.
+ * @param {TreeViewState<[UseTreeViewItemsReorderingSignature]>} state The state of the tree view.
+ * @returns {TreeViewItemsReorderingState | null} The items reordering state.
+ */
+export declare const selectorItemsReordering: (state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+  draggedItemId: string;
+  targetItemId: string;
+  newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+  action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+} | null;
+/**
+ * Get the properties of the dragged item.
+ * @param {TreeViewState<[UseTreeViewItemsSignature, UseTreeViewItemsReorderingSignature]>} state The state of the tree view.
+ * @param {string} itemId The id of the item.
+ * @returns {TreeViewItemDraggedItemProperties | null} The properties of the dragged item if the current item is being dragged, `null` otherwise.
+ */
+export declare const selectorItemsReorderingDraggedItemProperties: ((state: any, itemId: string) => {
+  newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+  action: import("@mui/x-tree-view").TreeViewItemsReorderingAction;
+  targetDepth: number;
+} | null) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null, resultFuncArgs_1: {
+    [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+  }, resultFuncArgs_2: string) => {
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction;
+    targetDepth: number;
+  } | null;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null, resultFuncArgs_1: {
+    [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+  }, resultFuncArgs_2: string) => {
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction;
+    targetDepth: number;
+  } | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction;
+    targetDepth: number;
+  } | null;
+  dependencies: [(state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null, ((state: import("@mui/x-tree-view/internals/corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("@mui/x-tree-view/internals").UseTreeViewItemsState<import("@mui/x-tree-view").TreeViewDefaultItemModelProperties> & Partial<{}> & {
+    cacheKey: import("@mui/x-tree-view/internals/models").TreeViewStateCacheKey;
+  }) => {
+    [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      disabledItemsFocusable: boolean;
+      itemModelLookup: {
+        [itemId: string]: import("@mui/x-tree-view").TreeViewBaseItem<import("@mui/x-tree-view").TreeViewDefaultItemModelProperties>;
+      };
+      itemMetaLookup: {
+        [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+      };
+      itemOrderedChildrenIdsLookup: {
+        [parentItemId: string]: string[];
+      };
+      itemChildrenIndexesLookup: {
+        [parentItemId: string]: {
+          [itemId: string]: number;
+        };
+      };
+    }) => {
+      [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      disabledItemsFocusable: boolean;
+      itemModelLookup: {
+        [itemId: string]: import("@mui/x-tree-view").TreeViewBaseItem<import("@mui/x-tree-view").TreeViewDefaultItemModelProperties>;
+      };
+      itemMetaLookup: {
+        [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+      };
+      itemOrderedChildrenIdsLookup: {
+        [parentItemId: string]: string[];
+      };
+      itemChildrenIndexesLookup: {
+        [parentItemId: string]: {
+          [itemId: string]: number;
+        };
+      };
+    }) => {
+      [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+    }) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => {
+      [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+    };
+    dependencies: [import("@mui/x-tree-view/internals/utils/selectors").TreeViewRootSelector<import("@mui/x-tree-view/internals").UseTreeViewItemsSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if the current item is a valid target for the dragged item.
+ * @param {TreeViewState<[UseTreeViewItemsReorderingSignature]>} state The state of the tree view.
+ * @param {string} itemId The id of the item.
+ * @returns {boolean} `true` if the current item is a valid target for the dragged item, `false` otherwise.
+ */
+export declare const selectorItemsReorderingIsValidTarget: ((state: any, itemId: string) => boolean | null) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null, resultFuncArgs_1: string) => boolean | null;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null, resultFuncArgs_1: string) => boolean | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean | null;
+  dependencies: [(state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

package/{node → esm}/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.selectors.js

@@ -1,16 +1,10 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.selectorItemsReorderingIsValidTarget = exports.selectorItemsReorderingDraggedItemProperties = exports.selectorItemsReordering = void 0;
-var _internals = require("@mui/x-tree-view/internals");
+import { createSelector, selectorItemMetaLookup } from '@mui/x-tree-view/internals';
 /**
  * Get the items reordering state.
  * @param {TreeViewState<[UseTreeViewItemsReorderingSignature]>} state The state of the tree view.
  * @returns {TreeViewItemsReorderingState | null} The items reordering state.
  */
-const selectorItemsReordering = state => state.itemsReordering;
+export const selectorItemsReordering = state => state.itemsReordering;
 
 /**
  * Get the properties of the dragged item.
@@ -18,8 +12,7 @@ const selectorItemsReordering = state => state.itemsReordering;
  * @param {string} itemId The id of the item.
  * @returns {TreeViewItemDraggedItemProperties | null} The properties of the dragged item if the current item is being dragged, `null` otherwise.
  */
-exports.selectorItemsReordering = selectorItemsReordering;
-const selectorItemsReorderingDraggedItemProperties = exports.selectorItemsReorderingDraggedItemProperties = (0, _internals.createSelector)([selectorItemsReordering, _internals.selectorItemMetaLookup, (_, itemId) => itemId], (itemsReordering, itemMetaLookup, itemId) => {
+export const selectorItemsReorderingDraggedItemProperties = createSelector([selectorItemsReordering, selectorItemMetaLookup, (_, itemId) => itemId], (itemsReordering, itemMetaLookup, itemId) => {
   if (!itemsReordering || itemsReordering.targetItemId !== itemId || itemsReordering.action == null) {
     return null;
   }
@@ -39,4 +32,4 @@ const selectorItemsReorderingDraggedItemProperties = exports.selectorItemsReorde
  * @param {string} itemId The id of the item.
  * @returns {boolean} `true` if the current item is a valid target for the dragged item, `false` otherwise.
  */
-const selectorItemsReorderingIsValidTarget = exports.selectorItemsReorderingIsValidTarget = (0, _internals.createSelector)([selectorItemsReordering, (_, itemId) => itemId], (itemsReordering, itemId) => itemsReordering && itemsReordering.draggedItemId !== itemId);
+export const selectorItemsReorderingIsValidTarget = createSelector([selectorItemsReordering, (_, itemId) => itemId], (itemsReordering, itemId) => itemsReordering && itemsReordering.draggedItemId !== itemId);

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

@@ -0,0 +1,132 @@
+import * as React from 'react';
+import { DefaultizedProps } from '@mui/x-internals/types';
+import { TreeViewPluginSignature, UseTreeViewItemsSignature } from '@mui/x-tree-view/internals';
+import { TreeViewItemId, TreeViewItemsReorderingAction, TreeViewCancellableEventHandler } from '@mui/x-tree-view/models';
+import { TreeItemDragAndDropOverlayProps } from '@mui/x-tree-view/TreeItemDragAndDropOverlay';
+export interface UseTreeViewItemsReorderingInstance {
+  /**
+   * Check if a given item can be dragged.
+   * @param {TreeViewItemId} itemId The id of the item to check.
+   * @returns {boolean} `true` if the item can be dragged, `false` otherwise.
+   */
+  canItemBeDragged: (itemId: TreeViewItemId) => boolean;
+  /**
+   * Get the valid reordering action if a given item is the target of the ongoing reordering.
+   * @param {TreeViewItemId} itemId The id of the item to get the action of.
+   * @returns {TreeViewItemItemReorderingValidActions} The valid actions for the item.
+   */
+  getDroppingTargetValidActions: (itemId: TreeViewItemId) => TreeViewItemItemReorderingValidActions;
+  /**
+   * Start a reordering for the given item.
+   * @param {TreeViewItemId} itemId The id of the item to start the reordering for.
+   */
+  startDraggingItem: (itemId: TreeViewItemId) => void;
+  /**
+   * Stop the reordering of a given item.
+   * @param {TreeViewItemId} itemId The id of the item to stop the reordering for.
+   */
+  stopDraggingItem: (itemId: TreeViewItemId) => void;
+  /**
+   * Set the new target item for the ongoing reordering.
+   * The action will be determined based on the position of the cursor inside the target and the valid actions for this target.
+   * @param {object} params The params describing the new target item.
+   * @param {TreeViewItemId} params.itemId The id of the new target item.
+   * @param {TreeViewItemItemReorderingValidActions} params.validActions The valid actions for the new target item.
+   * @param {number} params.targetHeight The height of the target item.
+   * @param {number} params.cursorY The Y coordinate of the mouse cursor.
+   * @param {number} params.cursorX The X coordinate of the mouse cursor.
+   * @param {HTMLDivElement} params.contentElement The DOM element rendered for the content slot.
+   */
+  setDragTargetItem: (params: {
+    itemId: TreeViewItemId;
+    validActions: TreeViewItemItemReorderingValidActions;
+    targetHeight: number;
+    cursorY: number;
+    cursorX: number;
+    contentElement: HTMLDivElement;
+  }) => void;
+}
+export interface TreeViewItemReorderPosition {
+  parentId: string | null;
+  index: number;
+}
+export type TreeViewItemItemReorderingValidActions = { [key in TreeViewItemsReorderingAction]?: TreeViewItemReorderPosition };
+export interface UseTreeViewItemsReorderingParameters {
+  /**
+   * If `true`, the reordering of items is enabled.
+   * @default false
+   */
+  itemsReordering?: boolean;
+  /**
+   * Determine if a given item can be reordered.
+   * @param {string} itemId The id of the item to check.
+   * @returns {boolean} `true` if the item can be reordered.
+   * @default () => true
+   */
+  isItemReorderable?: (itemId: string) => boolean;
+  /**
+   * Used to determine if a given item can move to some new position.
+   * @param {object} params The params describing the item re-ordering.
+   * @param {string} params.itemId The id of the item that is being moved to a new position.
+   * @param {TreeViewItemReorderPosition} params.oldPosition The old position of the item.
+   * @param {TreeViewItemReorderPosition} params.newPosition The new position of the item.
+   * @returns {boolean} `true` if the item can move to the new position.
+   */
+  canMoveItemToNewPosition?: (params: {
+    itemId: string;
+    oldPosition: TreeViewItemReorderPosition;
+    newPosition: TreeViewItemReorderPosition;
+  }) => boolean;
+  /**
+   * Callback fired when a Tree Item is moved in the tree.
+   * @param {object} params The params describing the item re-ordering.
+   * @param {string} params.itemId The id of the item moved.
+   * @param {TreeViewItemReorderPosition} params.oldPosition The old position of the item.
+   * @param {TreeViewItemReorderPosition} params.newPosition The new position of the item.
+   */
+  onItemPositionChange?: (params: {
+    itemId: string;
+    oldPosition: TreeViewItemReorderPosition;
+    newPosition: TreeViewItemReorderPosition;
+  }) => void;
+}
+export type UseTreeViewItemsReorderingDefaultizedParameters = DefaultizedProps<UseTreeViewItemsReorderingParameters, 'itemsReordering'>;
+export interface UseTreeViewItemsReorderingState {
+  itemsReordering: {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: TreeViewItemReorderPosition | null;
+    action: TreeViewItemsReorderingAction | null;
+  } | null;
+}
+interface UseTreeViewItemsReorderingContextValue {
+  itemsReordering: {
+    enabled: boolean;
+    isItemReorderable: ((itemId: string) => boolean) | undefined;
+  };
+}
+export type UseTreeViewItemsReorderingSignature = TreeViewPluginSignature<{
+  params: UseTreeViewItemsReorderingParameters;
+  defaultizedParams: UseTreeViewItemsReorderingDefaultizedParameters;
+  instance: UseTreeViewItemsReorderingInstance;
+  state: UseTreeViewItemsReorderingState;
+  contextValue: UseTreeViewItemsReorderingContextValue;
+  dependencies: [UseTreeViewItemsSignature];
+}>;
+export interface UseTreeItemRootSlotPropsFromItemsReordering {
+  draggable?: true;
+  onDragStart?: TreeViewCancellableEventHandler<React.DragEvent>;
+  onDragOver?: TreeViewCancellableEventHandler<React.DragEvent>;
+  onDragEnd?: TreeViewCancellableEventHandler<React.DragEvent>;
+}
+export interface UseTreeItemContentSlotPropsFromItemsReordering {
+  onDragEnter?: TreeViewCancellableEventHandler<React.DragEvent>;
+  onDragOver?: TreeViewCancellableEventHandler<React.DragEvent>;
+}
+export interface UseTreeItemDragAndDropOverlaySlotPropsFromItemsReordering extends TreeItemDragAndDropOverlayProps {}
+declare module '@mui/x-tree-view/useTreeItem' {
+  interface UseTreeItemRootSlotOwnProps extends UseTreeItemRootSlotPropsFromItemsReordering {}
+  interface UseTreeItemContentSlotOwnProps extends UseTreeItemContentSlotPropsFromItemsReordering {}
+  interface UseTreeItemDragAndDropOverlaySlotOwnProps extends UseTreeItemDragAndDropOverlaySlotPropsFromItemsReordering {}
+}
+export {};

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

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

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

@@ -0,0 +1,37 @@
+import { TreeViewUsedStore, UseTreeViewItemsState } from '@mui/x-tree-view/internals';
+import { TreeViewItemId, TreeViewItemsReorderingAction } from '@mui/x-tree-view/models';
+import { TreeViewItemItemReorderingValidActions, TreeViewItemReorderPosition, UseTreeViewItemsReorderingSignature } from "./useTreeViewItemsReordering.types.js";
+/**
+ * Checks if the item with the id itemIdB is an ancestor of the item with the id itemIdA.
+ */
+export declare const isAncestor: (store: TreeViewUsedStore<UseTreeViewItemsReorderingSignature>, itemIdA: string, itemIdB: string) => boolean;
+interface GetNewPositionParams {
+  itemChildrenIndentation: string | number;
+  validActions: TreeViewItemItemReorderingValidActions;
+  targetHeight: number;
+  targetDepth: number;
+  cursorY: number;
+  cursorX: number;
+  contentElement: HTMLDivElement;
+}
+export declare const chooseActionToApply: ({
+  itemChildrenIndentation,
+  validActions,
+  targetHeight,
+  targetDepth,
+  cursorX,
+  cursorY,
+  contentElement
+}: GetNewPositionParams) => TreeViewItemsReorderingAction | null;
+export declare const moveItemInTree: <R extends {}>({
+  itemToMoveId,
+  oldPosition,
+  newPosition,
+  prevState
+}: {
+  itemToMoveId: TreeViewItemId;
+  oldPosition: TreeViewItemReorderPosition;
+  newPosition: TreeViewItemReorderPosition;
+  prevState: UseTreeViewItemsState<R>["items"];
+}) => UseTreeViewItemsState<R>["items"];
+export {};

package/{node → esm}/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.utils.js

@@ -1,17 +1,10 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.moveItemInTree = exports.isAncestor = exports.chooseActionToApply = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var _internals = require("@mui/x-tree-view/internals");
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID, selectorItemMeta } from '@mui/x-tree-view/internals';
 /**
  * Checks if the item with the id itemIdB is an ancestor of the item with the id itemIdA.
  */
-const isAncestor = (store, itemIdA, itemIdB) => {
-  const itemMetaA = (0, _internals.selectorItemMeta)(store.value, itemIdA);
+export const isAncestor = (store, itemIdA, itemIdB) => {
+  const itemMetaA = selectorItemMeta(store.value, itemIdA);
   if (itemMetaA.parentId === itemIdB) {
     return true;
   }
@@ -26,7 +19,6 @@ const isAncestor = (store, itemIdA, itemIdB) => {
  * @param {string | null} itemChildrenIndentation The indentation as passed to the `itemChildrenIndentation` prop.
  * @param {HTMLElement} contentElement The DOM element to which the indentation will be applied.
  */
-exports.isAncestor = isAncestor;
 const parseItemChildrenIndentation = (itemChildrenIndentation, contentElement) => {
   if (typeof itemChildrenIndentation === 'number') {
     return itemChildrenIndentation;
@@ -45,7 +37,7 @@ const parseItemChildrenIndentation = (itemChildrenIndentation, contentElement) =
   contentElement.removeChild(tempElement);
   return value;
 };
-const chooseActionToApply = ({
+export const chooseActionToApply = ({
   itemChildrenIndentation,
   validActions,
   targetHeight,
@@ -90,24 +82,23 @@ const chooseActionToApply = ({
   }
   return action;
 };
-exports.chooseActionToApply = chooseActionToApply;
-const moveItemInTree = ({
+export const moveItemInTree = ({
   itemToMoveId,
   oldPosition,
   newPosition,
   prevState
 }) => {
   const itemToMoveMeta = prevState.itemMetaLookup[itemToMoveId];
-  const oldParentId = oldPosition.parentId ?? _internals.TREE_VIEW_ROOT_PARENT_ID;
-  const newParentId = newPosition.parentId ?? _internals.TREE_VIEW_ROOT_PARENT_ID;
+  const oldParentId = oldPosition.parentId ?? TREE_VIEW_ROOT_PARENT_ID;
+  const newParentId = newPosition.parentId ?? TREE_VIEW_ROOT_PARENT_ID;
 
   // 1. Update the `itemOrderedChildrenIds`.
-  const itemOrderedChildrenIds = (0, _extends2.default)({}, prevState.itemOrderedChildrenIdsLookup);
+  const itemOrderedChildrenIds = _extends({}, prevState.itemOrderedChildrenIdsLookup);
   if (oldParentId === newParentId) {
     const updatedChildren = [...itemOrderedChildrenIds[oldParentId]];
     updatedChildren.splice(oldPosition.index, 1);
     updatedChildren.splice(newPosition.index, 0, itemToMoveId);
-    itemOrderedChildrenIds[itemToMoveMeta.parentId ?? _internals.TREE_VIEW_ROOT_PARENT_ID] = updatedChildren;
+    itemOrderedChildrenIds[itemToMoveMeta.parentId ?? TREE_VIEW_ROOT_PARENT_ID] = updatedChildren;
   } else {
     const updatedOldParentChildren = [...itemOrderedChildrenIds[oldParentId]];
     updatedOldParentChildren.splice(oldPosition.index, 1);
@@ -118,51 +109,50 @@ const moveItemInTree = ({
   }
 
   // 2. Update the `itemChildrenIndexes`
-  const itemChildrenIndexes = (0, _extends2.default)({}, prevState.itemChildrenIndexesLookup);
-  itemChildrenIndexes[oldParentId] = (0, _internals.buildSiblingIndexes)(itemOrderedChildrenIds[oldParentId]);
+  const itemChildrenIndexes = _extends({}, prevState.itemChildrenIndexesLookup);
+  itemChildrenIndexes[oldParentId] = buildSiblingIndexes(itemOrderedChildrenIds[oldParentId]);
   if (newParentId !== oldParentId) {
-    itemChildrenIndexes[newParentId] = (0, _internals.buildSiblingIndexes)(itemOrderedChildrenIds[newParentId]);
+    itemChildrenIndexes[newParentId] = buildSiblingIndexes(itemOrderedChildrenIds[newParentId]);
   }
 
   // 3. Update the `itemMetaLookup`
-  const itemMetaLookup = (0, _extends2.default)({}, prevState.itemMetaLookup);
+  const itemMetaLookup = _extends({}, prevState.itemMetaLookup);
 
   // 3.1 Update the `expandable` property of the old and the new parent
   function updateExpandable(itemId) {
     const isExpandable = itemOrderedChildrenIds[itemId].length > 0;
     if (itemMetaLookup[itemId].expandable !== isExpandable) {
-      itemMetaLookup[itemId] = (0, _extends2.default)({}, itemMetaLookup[itemId], {
+      itemMetaLookup[itemId] = _extends({}, itemMetaLookup[itemId], {
         expandable: isExpandable
       });
     }
   }
-  if (oldParentId !== _internals.TREE_VIEW_ROOT_PARENT_ID && oldParentId !== newParentId) {
+  if (oldParentId !== TREE_VIEW_ROOT_PARENT_ID && oldParentId !== newParentId) {
     updateExpandable(oldParentId);
   }
-  if (newParentId !== _internals.TREE_VIEW_ROOT_PARENT_ID && newParentId !== oldParentId) {
+  if (newParentId !== TREE_VIEW_ROOT_PARENT_ID && newParentId !== oldParentId) {
     updateExpandable(newParentId);
   }
 
   // 3.2 Update the `parentId` and `depth` properties of the item to move
   // The depth is always defined because drag&drop is only usable with Rich Tree View components.
   const itemToMoveDepth = newPosition.parentId == null ? 0 : itemMetaLookup[newParentId].depth + 1;
-  itemMetaLookup[itemToMoveId] = (0, _extends2.default)({}, itemToMoveMeta, {
+  itemMetaLookup[itemToMoveId] = _extends({}, itemToMoveMeta, {
     parentId: newPosition.parentId,
     depth: itemToMoveDepth
   });
 
   // 3.3 Update the depth of all the children of the item to move
   const updateItemDepth = (itemId, depth) => {
-    itemMetaLookup[itemId] = (0, _extends2.default)({}, itemMetaLookup[itemId], {
+    itemMetaLookup[itemId] = _extends({}, itemMetaLookup[itemId], {
       depth
     });
     itemOrderedChildrenIds[itemId]?.forEach(childId => updateItemDepth(childId, depth + 1));
   };
   itemOrderedChildrenIds[itemToMoveId]?.forEach(childId => updateItemDepth(childId, itemToMoveDepth + 1));
-  return (0, _extends2.default)({}, prevState, {
+  return _extends({}, prevState, {
     itemOrderedChildrenIdsLookup: itemOrderedChildrenIds,
     itemChildrenIndexesLookup: itemChildrenIndexes,
     itemMetaLookup
   });
-};
-exports.moveItemInTree = moveItemInTree;
+};

package/esm/internals/utils/releaseInfo.d.ts

@@ -0,0 +1 @@
+export declare const getReleaseInfo: () => any;