@mui/x-tree-view-pro 8.0.0-beta.0 → 8.0.0-beta.2

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

@@ -1,23 +1,84 @@
 import { TreeViewState } from '@mui/x-tree-view/internals';
 import { UseTreeViewItemsReorderingSignature } from "./useTreeViewItemsReordering.types.js";
 /**
- * Get the items reordering state.
+ * Get the properties of the current reordering.
  * @param {TreeViewState<[UseTreeViewItemsReorderingSignature]>} state The state of the tree view.
- * @returns {TreeViewItemsReorderingState | null} The items reordering state.
+ * @returns {TreeViewItemsReorderingState['currentReorder']} The properties of the current reordering.
  */
-export declare const selectorItemsReordering: (state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+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;
+} | 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 selectorItemsReorderingDraggedItemProperties: ((state: any, itemId: string) => {
+export declare const selectorDraggedItemProperties: ((state: any, itemId: string) => {
   newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
   action: import("@mui/x-tree-view").TreeViewItemsReorderingAction;
   targetDepth: number;
@@ -59,12 +120,73 @@ export declare const selectorItemsReorderingDraggedItemProperties: ((state: any,
     action: import("@mui/x-tree-view").TreeViewItemsReorderingAction;
     targetDepth: number;
   } | null;
-  dependencies: [(state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+  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, ((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<{}> & {
+  } | 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;
@@ -145,7 +267,7 @@ export declare const selectorItemsReorderingDraggedItemProperties: ((state: any,
  * @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) & {
+export declare const selectorIsItemValidReorderingTarget: ((state: any, itemId: string) => boolean | null) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -167,12 +289,124 @@ export declare const selectorItemsReorderingIsValidTarget: ((state: any, itemId:
     resetResultsCount: () => void;
   };
   lastResult: () => boolean | null;
-  dependencies: [(state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
+  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, (_: any, itemId: string) => string];
+  } | 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;

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

@@ -2,9 +2,16 @@ import { createSelector, selectorItemMetaLookup } from '@mui/x-tree-view/interna
 /**
  * Get the items reordering state.
  * @param {TreeViewState<[UseTreeViewItemsReorderingSignature]>} state The state of the tree view.
- * @returns {TreeViewItemsReorderingState | null} The items reordering state.
+ * @returns {TreeViewItemsReorderingState} The items reordering state.
  */
-export const selectorItemsReordering = state => state.itemsReordering;
+const selectorItemsReordering = state => state.itemsReordering;
+
+/**
+ * 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 const selectorCurrentItemReordering = createSelector([selectorItemsReordering], itemsReordering => itemsReordering.currentReorder);
 
 /**
  * Get the properties of the dragged item.
@@ -12,16 +19,16 @@ export 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.
  */
-export const selectorItemsReorderingDraggedItemProperties = createSelector([selectorItemsReordering, selectorItemMetaLookup, (_, itemId) => itemId], (itemsReordering, itemMetaLookup, itemId) => {
-  if (!itemsReordering || itemsReordering.targetItemId !== itemId || itemsReordering.action == null) {
+export const selectorDraggedItemProperties = createSelector([selectorCurrentItemReordering, selectorItemMetaLookup, (_, itemId) => itemId], (currentReorder, itemMetaLookup, itemId) => {
+  if (!currentReorder || currentReorder.targetItemId !== itemId || currentReorder.action == null) {
     return null;
   }
-  const targetDepth = itemsReordering.newPosition?.parentId == null ? 0 :
+  const targetDepth = currentReorder.newPosition?.parentId == null ? 0 :
   // The depth is always defined because drag&drop is only usable with Rich Tree View components.
   itemMetaLookup[itemId].depth + 1;
   return {
-    newPosition: itemsReordering.newPosition,
-    action: itemsReordering.action,
+    newPosition: currentReorder.newPosition,
+    action: currentReorder.action,
     targetDepth
   };
 });
@@ -32,4 +39,12 @@ export const selectorItemsReorderingDraggedItemProperties = createSelector([sele
  * @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 const selectorItemsReorderingIsValidTarget = createSelector([selectorItemsReordering, (_, itemId) => itemId], (itemsReordering, itemId) => itemsReordering && itemsReordering.draggedItemId !== itemId);
+export const selectorIsItemValidReorderingTarget = createSelector([selectorCurrentItemReordering, (_, itemId) => itemId], (currentReorder, itemId) => currentReorder && currentReorder.draggedItemId !== itemId);
+
+/**
+ * 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 const selectorCanItemBeReordered = createSelector([selectorItemsReordering, (_, itemId) => itemId], (itemsReordering, itemId) => itemsReordering.isItemReorderable(itemId));

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

@@ -93,16 +93,13 @@ export interface UseTreeViewItemsReorderingParameters {
 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;
+    isItemReorderable: (itemId: string) => boolean;
+    currentReorder: {
+      draggedItemId: string;
+      targetItemId: string;
+      newPosition: TreeViewItemReorderPosition | null;
+      action: TreeViewItemsReorderingAction | null;
+    } | null;
   };
 }
 export type UseTreeViewItemsReorderingSignature = TreeViewPluginSignature<{
@@ -110,7 +107,6 @@ export type UseTreeViewItemsReorderingSignature = TreeViewPluginSignature<{
   defaultizedParams: UseTreeViewItemsReorderingDefaultizedParameters;
   instance: UseTreeViewItemsReorderingInstance;
   state: UseTreeViewItemsReorderingState;
-  contextValue: UseTreeViewItemsReorderingContextValue;
   dependencies: [UseTreeViewItemsSignature];
 }>;
 export interface UseTreeItemRootSlotPropsFromItemsReordering {
@@ -128,5 +124,4 @@ declare module '@mui/x-tree-view/useTreeItem' {
   interface UseTreeItemRootSlotOwnProps extends UseTreeItemRootSlotPropsFromItemsReordering {}
   interface UseTreeItemContentSlotOwnProps extends UseTreeItemContentSlotPropsFromItemsReordering {}
   interface UseTreeItemDragAndDropOverlaySlotOwnProps extends UseTreeItemDragAndDropOverlaySlotPropsFromItemsReordering {}
-}
-export {};
+}

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

@@ -1,7 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import useLazyRef from '@mui/utils/useLazyRef';
-import { warnOnce } from '@mui/x-internals/warning';
 import useEventCallback from '@mui/utils/useEventCallback';
 import { selectorItemMeta, selectorIsItemSelected, useInstanceEventHandler, selectorDataSourceState, selectorGetTreeItemError } from '@mui/x-tree-view/internals';
 import { DataSourceCacheDefault } from '@mui/x-tree-view/utils';
@@ -26,7 +25,7 @@ export const useTreeViewLazyLoading = ({
   params,
   store
 }) => {
-  const isLazyLoadingEnabled = params.dataSource?.getChildrenCount !== undefined;
+  const isLazyLoadingEnabled = !!params.dataSource;
   const firstRenderRef = React.useRef(true);
   const nestedDataManager = useLazyRef(() => new NestedDataManager(instance)).current;
   const cacheRef = useLazyRef(() => getCache(params.dataSourceCache));
@@ -258,24 +257,6 @@ export const useTreeViewLazyLoading = ({
     publicAPI: {}
   };
 };
-useTreeViewLazyLoading.getDefaultizedParams = ({
-  params,
-  experimentalFeatures
-}) => {
-  const canUseFeature = experimentalFeatures?.lazyLoading;
-  if (process.env.NODE_ENV !== 'production') {
-    if (params.dataSource && !canUseFeature) {
-      warnOnce(['MUI X: The label editing feature requires the `lazyLoading` experimental feature to be enabled.', 'You can do it by passing `experimentalFeatures={{ lazyLoading: true}}` to the Rich Tree View Pro component.', 'Check the documentation for more details: https://mui.com/x/react-tree-view/rich-tree-view/lazy-loading/']);
-    }
-  }
-  const defaultDataSource = params?.dataSource ?? {
-    getChildrenCount: () => 0,
-    getTreeItems: () => Promise.resolve([])
-  };
-  return _extends({}, params, {
-    dataSource: canUseFeature ? defaultDataSource : {}
-  });
-};
 useTreeViewLazyLoading.getInitialState = () => ({
   lazyLoading: {
     enabled: false,

package/esm/internals/utils/releaseInfo.js

@@ -1,6 +1,6 @@
 import ponyfillGlobal from '@mui/utils/ponyfillGlobal';
 export const getReleaseInfo = () => {
-  const releaseInfo = "MTc0MjI0ODgwMDAwMA==";
+  const releaseInfo = "MTc0MzExMjgwMDAwMA==";
   if (process.env.NODE_ENV !== 'production') {
     // A simple hack to set the value in the test environment (has no build step).
     // eslint-disable-next-line no-useless-concat

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-tree-view-pro v8.0.0-beta.0
+ * @mui/x-tree-view-pro v8.0.0-beta.2
  *
  * @license MUI X Commercial
  * This source code is licensed under the commercial license found in the

package/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.itemPlugin.js

@@ -15,15 +15,15 @@ const useTreeViewItemsReorderingItemPlugin = ({
 }) => {
   const {
     instance,
-    store,
-    itemsReordering
+    store
   } = (0, _internals.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 = (0, _internals.useSelector)(store, _useTreeViewItemsReordering.selectorDraggedItemProperties, itemId);
+  const canItemBeReordered = (0, _internals.useSelector)(store, _useTreeViewItemsReordering.selectorCanItemBeReordered);
+  const isValidTarget = (0, _internals.useSelector)(store, _useTreeViewItemsReordering.selectorIsItemValidReorderingTarget, itemId);
   return {
     propsEnhancers: {
       root: ({
@@ -31,7 +31,7 @@ const useTreeViewItemsReorderingItemPlugin = ({
         contentRefObject,
         externalEventHandlers
       }) => {
-        if (!itemsReordering.enabled || itemsReordering.isItemReorderable && !itemsReordering.isItemReorderable(itemId)) {
+        if (!canItemBeReordered) {
           return {};
         }
         const handleDragStart = event => {