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

package/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.js

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

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

@@ -1,15 +1,15 @@
 import { TreeViewState } from '@mui/x-tree-view/internals';
-import { UseTreeViewItemsReorderingSignature } from './useTreeViewItemsReordering.types';
+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;
+  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.
@@ -18,122 +18,122 @@ export declare const selectorItemsReordering: (state: TreeViewState<[UseTreeView
  * @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) & {
+  } | 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: {
-        draggedItemId: string;
-        targetItemId: string;
-        newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
-        action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
-    } | null, resultFuncArgs_1: {
+      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;
-    }, resultFuncArgs_2: string) => {
-        newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
-        action: import("@mui/x-tree-view").TreeViewItemsReorderingAction;
-        targetDepth: number;
-    } | null;
+      };
+      itemOrderedChildrenIdsLookup: {
+        [parentItemId: string]: string[];
+      };
+      itemChildrenIndexesLookup: {
+        [parentItemId: string]: {
+          [itemId: string]: number;
+        };
+      };
+    }) => {
+      [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+    };
     memoizedResultFunc: ((resultFuncArgs_0: {
-        draggedItemId: string;
-        targetItemId: string;
-        newPosition: import("./useTreeViewItemsReordering.types").TreeViewItemReorderPosition | null;
-        action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
-    } | null, resultFuncArgs_1: {
+      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;
-    }, 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;
+      };
+      itemOrderedChildrenIdsLookup: {
+        [parentItemId: string]: string[];
+      };
+      itemChildrenIndexesLookup: {
+        [parentItemId: string]: {
+          [itemId: string]: number;
+        };
+      };
     }) => {
-        [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
+      [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];
+      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.
@@ -142,38 +142,38 @@ export declare const selectorItemsReorderingDraggedItemProperties: ((state: any,
  * @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;
 } & {
-    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;
-};
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -1,10 +1,16 @@
-import { createSelector, selectorItemMetaLookup } from '@mui/x-tree-view/internals';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectorItemsReorderingIsValidTarget = exports.selectorItemsReorderingDraggedItemProperties = exports.selectorItemsReordering = void 0;
+var _internals = require("@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.
  */
-export const selectorItemsReordering = state => state.itemsReordering;
+const selectorItemsReordering = state => state.itemsReordering;
 
 /**
  * Get the properties of the dragged item.
@@ -12,7 +18,8 @@ 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) => {
+exports.selectorItemsReordering = selectorItemsReordering;
+const selectorItemsReorderingDraggedItemProperties = exports.selectorItemsReorderingDraggedItemProperties = (0, _internals.createSelector)([selectorItemsReordering, _internals.selectorItemMetaLookup, (_, itemId) => itemId], (itemsReordering, itemMetaLookup, itemId) => {
   if (!itemsReordering || itemsReordering.targetItemId !== itemId || itemsReordering.action == null) {
     return null;
   }
@@ -32,4 +39,4 @@ 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);
+const selectorItemsReorderingIsValidTarget = exports.selectorItemsReorderingIsValidTarget = (0, _internals.createSelector)([selectorItemsReordering, (_, itemId) => itemId], (itemsReordering, itemId) => itemsReordering && itemsReordering.draggedItemId !== itemId);