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

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

@@ -1,29 +1,21 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTreeViewItemsReorderingItemPlugin = exports.isAndroid = void 0;
-var React = _interopRequireWildcard(require("react"));
-var _internals = require("@mui/x-tree-view/internals");
-var _useTreeViewItemsReordering = require("./useTreeViewItemsReordering.selectors");
-const isAndroid = () => navigator.userAgent.toLowerCase().includes('android');
-exports.isAndroid = isAndroid;
-const useTreeViewItemsReorderingItemPlugin = ({
+import * as React from 'react';
+import { useTreeViewContext, isTargetInDescendants, useSelector } from '@mui/x-tree-view/internals';
+import { selectorCanItemBeReordered, selectorDraggedItemProperties, selectorIsItemValidReorderingTarget } from "./useTreeViewItemsReordering.selectors.js";
+export const isAndroid = () => navigator.userAgent.toLowerCase().includes('android');
+export const useTreeViewItemsReorderingItemPlugin = ({
   props
 }) => {
   const {
     instance,
-    store,
-    itemsReordering
-  } = (0, _internals.useTreeViewContext)();
+    store
+  } = useTreeViewContext();
   const {
     itemId
   } = props;
   const validActionsRef = React.useRef(null);
-  const draggedItemProperties = (0, _internals.useSelector)(store, _useTreeViewItemsReordering.selectorItemsReorderingDraggedItemProperties, itemId);
-  const isValidTarget = (0, _internals.useSelector)(store, _useTreeViewItemsReordering.selectorItemsReorderingIsValidTarget, itemId);
+  const draggedItemProperties = useSelector(store, selectorDraggedItemProperties, itemId);
+  const canItemBeReordered = useSelector(store, selectorCanItemBeReordered);
+  const isValidTarget = useSelector(store, selectorIsItemValidReorderingTarget, itemId);
   return {
     propsEnhancers: {
       root: ({
@@ -31,7 +23,7 @@ const useTreeViewItemsReorderingItemPlugin = ({
         contentRefObject,
         externalEventHandlers
       }) => {
-        if (!itemsReordering.enabled || itemsReordering.isItemReorderable && !itemsReordering.isItemReorderable(itemId)) {
+        if (!canItemBeReordered) {
           return {};
         }
         const handleDragStart = event => {
@@ -42,7 +34,7 @@ const useTreeViewItemsReorderingItemPlugin = ({
 
           // We don't use `event.currentTarget` here.
           // This is to allow people to pass `onDragStart` to another element than the root.
-          if ((0, _internals.isTargetInDescendants)(event.target, rootRefObject.current)) {
+          if (isTargetInDescendants(event.target, rootRefObject.current)) {
             return;
           }
 
@@ -131,5 +123,4 @@ const useTreeViewItemsReorderingItemPlugin = ({
       }
     }
   };
-};
-exports.useTreeViewItemsReorderingItemPlugin = useTreeViewItemsReorderingItemPlugin;
+};

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

@@ -0,0 +1,203 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+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 { selectorCurrentItemReordering } from "./useTreeViewItemsReordering.selectors.js";
+export const useTreeViewItemsReordering = ({
+  params,
+  store
+}) => {
+  const canItemBeDragged = React.useCallback(itemId => {
+    if (!params.itemsReordering) {
+      return false;
+    }
+    const isItemReorderable = params.isItemReorderable;
+    if (isItemReorderable) {
+      return isItemReorderable(itemId);
+    }
+    return true;
+  }, [params.itemsReordering, params.isItemReorderable]);
+  const getDroppingTargetValidActions = React.useCallback(itemId => {
+    const currentReorder = selectorCurrentItemReordering(store.value);
+    if (!currentReorder) {
+      throw new Error('There is no ongoing reordering.');
+    }
+    if (itemId === currentReorder.draggedItemId) {
+      return {};
+    }
+    const canMoveItemToNewPosition = params.canMoveItemToNewPosition;
+    const targetItemMeta = selectorItemMeta(store.value, itemId);
+    const targetItemIndex = selectorItemIndex(store.value, targetItemMeta.id);
+    const draggedItemMeta = selectorItemMeta(store.value, currentReorder.draggedItemId);
+    const draggedItemIndex = selectorItemIndex(store.value, draggedItemMeta.id);
+    const isTargetLastSibling = targetItemIndex === selectorItemOrderedChildrenIds(store.value, targetItemMeta.parentId).length - 1;
+    const oldPosition = {
+      parentId: draggedItemMeta.parentId,
+      index: draggedItemIndex
+    };
+    const checkIfPositionIsValid = positionAfterAction => {
+      let isValid;
+      // If the new position is equal to the old one, we don't want to show any dropping UI.
+      if (positionAfterAction.parentId === oldPosition.parentId && positionAfterAction.index === oldPosition.index) {
+        isValid = false;
+      } else if (canMoveItemToNewPosition) {
+        isValid = canMoveItemToNewPosition({
+          itemId: currentReorder.draggedItemId,
+          oldPosition,
+          newPosition: positionAfterAction
+        });
+      } else {
+        isValid = true;
+      }
+      return isValid;
+    };
+    const positionsAfterAction = {
+      'make-child': {
+        parentId: targetItemMeta.id,
+        index: 0
+      },
+      'reorder-above': {
+        parentId: targetItemMeta.parentId,
+        index: targetItemMeta.parentId === draggedItemMeta.parentId && targetItemIndex > draggedItemIndex ? targetItemIndex - 1 : targetItemIndex
+      },
+      'reorder-below': !targetItemMeta.expandable || isTargetLastSibling ? {
+        parentId: targetItemMeta.parentId,
+        index: targetItemMeta.parentId === draggedItemMeta.parentId && targetItemIndex > draggedItemIndex ? targetItemIndex : targetItemIndex + 1
+      } : null,
+      'move-to-parent': targetItemMeta.parentId == null ? null : {
+        parentId: targetItemMeta.parentId,
+        index: selectorItemOrderedChildrenIds(store.value, targetItemMeta.parentId).length
+      }
+    };
+    const validActions = {};
+    Object.keys(positionsAfterAction).forEach(action => {
+      const positionAfterAction = positionsAfterAction[action];
+      if (positionAfterAction != null && checkIfPositionIsValid(positionAfterAction)) {
+        validActions[action] = positionAfterAction;
+      }
+    });
+    return validActions;
+  }, [store, params.canMoveItemToNewPosition]);
+  const startDraggingItem = React.useCallback(itemId => {
+    store.update(prevState => _extends({}, prevState, {
+      itemsReordering: _extends({}, prevState.itemsReordering, {
+        currentReorder: {
+          targetItemId: itemId,
+          draggedItemId: itemId,
+          action: null,
+          newPosition: null
+        }
+      })
+    }));
+  }, [store]);
+  const stopDraggingItem = React.useCallback(itemId => {
+    const currentReorder = selectorCurrentItemReordering(store.value);
+    if (currentReorder == null || currentReorder.draggedItemId !== itemId) {
+      return;
+    }
+    if (currentReorder.draggedItemId === currentReorder.targetItemId || currentReorder.action == null || currentReorder.newPosition == null) {
+      store.update(prevState => _extends({}, prevState, {
+        itemsReordering: _extends({}, prevState.itemsReordering, {
+          currentReorder: null
+        })
+      }));
+      return;
+    }
+    const draggedItemMeta = selectorItemMeta(store.value, currentReorder.draggedItemId);
+    const oldPosition = {
+      parentId: draggedItemMeta.parentId,
+      index: selectorItemIndex(store.value, draggedItemMeta.id)
+    };
+    const newPosition = currentReorder.newPosition;
+    store.update(prevState => _extends({}, prevState, {
+      itemsReordering: _extends({}, prevState.itemsReordering, {
+        currentReorder: null
+      }),
+      items: moveItemInTree({
+        itemToMoveId: itemId,
+        newPosition,
+        oldPosition,
+        prevState: prevState.items
+      })
+    }));
+    const onItemPositionChange = params.onItemPositionChange;
+    onItemPositionChange?.({
+      itemId,
+      newPosition,
+      oldPosition
+    });
+  }, [store, params.onItemPositionChange]);
+  const setDragTargetItem = React.useCallback(({
+    itemId,
+    validActions,
+    targetHeight,
+    cursorY,
+    cursorX,
+    contentElement
+  }) => {
+    store.update(prevState => {
+      const prevItemReorder = prevState.itemsReordering.currentReorder;
+      if (prevItemReorder == null || isAncestor(store, itemId, prevItemReorder.draggedItemId)) {
+        return prevState;
+      }
+      const action = chooseActionToApply({
+        itemChildrenIndentation: params.itemChildrenIndentation,
+        validActions,
+        targetHeight,
+        targetDepth: prevState.items.itemMetaLookup[itemId].depth,
+        cursorY,
+        cursorX,
+        contentElement
+      });
+      const newPosition = action == null ? null : validActions[action];
+      if (prevItemReorder.targetItemId === itemId && prevItemReorder.action === action && prevItemReorder.newPosition?.parentId === newPosition?.parentId && prevItemReorder.newPosition?.index === newPosition?.index) {
+        return prevState;
+      }
+      return _extends({}, prevState, {
+        itemsReordering: _extends({}, prevState.itemsReordering, {
+          currentReorder: _extends({}, prevItemReorder, {
+            targetItemId: itemId,
+            newPosition,
+            action
+          })
+        })
+      });
+    });
+  }, [store, params.itemChildrenIndentation]);
+  useEnhancedEffect(() => {
+    store.update(prevState => _extends({}, prevState, {
+      itemsReordering: _extends({}, prevState.itemsReordering, {
+        isItemReorderable: params.itemsReordering ? params.isItemReorderable ?? (() => true) : () => false
+      })
+    }));
+  }, [store, params.itemsReordering, params.isItemReorderable]);
+  return {
+    instance: {
+      canItemBeDragged,
+      getDroppingTargetValidActions,
+      startDraggingItem,
+      stopDraggingItem,
+      setDragTargetItem
+    }
+  };
+};
+useTreeViewItemsReordering.itemPlugin = useTreeViewItemsReorderingItemPlugin;
+useTreeViewItemsReordering.getDefaultizedParams = ({
+  params
+}) => _extends({}, params, {
+  itemsReordering: params.itemsReordering ?? false
+});
+useTreeViewItemsReordering.getInitialState = params => ({
+  itemsReordering: {
+    currentReorder: null,
+    isItemReorderable: params.itemsReordering ? params.isItemReorderable ?? (() => true) : () => false
+  }
+});
+useTreeViewItemsReordering.params = {
+  itemsReordering: true,
+  isItemReorderable: true,
+  canMoveItemToNewPosition: true,
+  onItemPositionChange: true
+};

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

@@ -0,0 +1,417 @@
+import { TreeViewState } from '@mui/x-tree-view/internals';
+import { UseTreeViewItemsReorderingSignature } from "./useTreeViewItemsReordering.types.js";
+/**
+ * Get the properties of the current reordering.
+ * @param {TreeViewState<[UseTreeViewItemsReorderingSignature]>} state The state of the tree view.
+ * @returns {TreeViewItemsReorderingState['currentReorder']} The properties of the current reordering.
+ */
+export declare const selectorCurrentItemReordering: ((state: import("@mui/x-tree-view/internals/corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewItemsReordering.types").UseTreeViewItemsReorderingState & Partial<{}> & {
+  cacheKey: import("@mui/x-tree-view/internals/models").TreeViewStateCacheKey;
+}) => {
+  draggedItemId: string;
+  targetItemId: string;
+  newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+  action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+} | null) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    isItemReorderable: (itemId: string) => boolean;
+    currentReorder: {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null;
+  }) => {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    isItemReorderable: (itemId: string) => boolean;
+    currentReorder: {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null;
+  }) => {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null;
+  dependencies: [(state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+    isItemReorderable: (itemId: string) => boolean;
+    currentReorder: {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null;
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * 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 selectorDraggedItemProperties: ((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: import("@mui/x-tree-view/internals/corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewItemsReordering.types").UseTreeViewItemsReorderingState & Partial<{}> & {
+    cacheKey: import("@mui/x-tree-view/internals/models").TreeViewStateCacheKey;
+  }) => {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      isItemReorderable: (itemId: string) => boolean;
+      currentReorder: {
+        draggedItemId: string;
+        targetItemId: string;
+        newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+        action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+      } | null;
+    }) => {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      isItemReorderable: (itemId: string) => boolean;
+      currentReorder: {
+        draggedItemId: string;
+        targetItemId: string;
+        newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+        action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+      } | null;
+    }) => {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null;
+    dependencies: [(state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+      isItemReorderable: (itemId: string) => boolean;
+      currentReorder: {
+        draggedItemId: string;
+        targetItemId: string;
+        newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+        action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+      } | null;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, ((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;
+        };
+      };
+      loading: boolean;
+      error: Error | null;
+    }) => {
+      [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;
+        };
+      };
+      loading: boolean;
+      error: Error | null;
+    }) => {
+      [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 selectorIsItemValidReorderingTarget: ((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: import("@mui/x-tree-view/internals/corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewItemsReordering.types").UseTreeViewItemsReorderingState & Partial<{}> & {
+    cacheKey: import("@mui/x-tree-view/internals/models").TreeViewStateCacheKey;
+  }) => {
+    draggedItemId: string;
+    targetItemId: string;
+    newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+  } | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      isItemReorderable: (itemId: string) => boolean;
+      currentReorder: {
+        draggedItemId: string;
+        targetItemId: string;
+        newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+        action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+      } | null;
+    }) => {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      isItemReorderable: (itemId: string) => boolean;
+      currentReorder: {
+        draggedItemId: string;
+        targetItemId: string;
+        newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+        action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+      } | null;
+    }) => {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null;
+    dependencies: [(state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+      isItemReorderable: (itemId: string) => boolean;
+      currentReorder: {
+        draggedItemId: string;
+        targetItemId: string;
+        newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+        action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+      } | null;
+    }];
+    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 items can be reordered.
+ * @param {TreeViewState<[UseTreeViewItemsReorderingSignature]>} state The state of the tree view.
+ * @param {string} itemId The id of the item.
+ * @returns {boolean} `true` if the items can be reordered, `false` otherwise.
+ */
+export declare const selectorCanItemBeReordered: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    isItemReorderable: (itemId: string) => boolean;
+    currentReorder: {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null;
+  }, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    isItemReorderable: (itemId: string) => boolean;
+    currentReorder: {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
+      action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
+    } | null;
+  }, resultFuncArgs_1: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [(state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+    isItemReorderable: (itemId: string) => boolean;
+    currentReorder: {
+      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;
+};