@mui/x-tree-view-pro 8.23.0 → 8.24.0

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

@@ -1,107 +0,0 @@
-import { DefaultizedProps } from '@mui/x-internals/types';
-import { TreeViewPluginSignature, UseTreeViewItemsSignature } from '@mui/x-tree-view/internals';
-import { TreeViewItemId, TreeViewItemsReorderingAction } from '@mui/x-tree-view/models';
-export interface UseTreeViewItemsReorderingInstance {
-  /**
-   * 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;
-  /**
-   * Complete the reordering of a given item.
-   * @param {TreeViewItemId} itemId The id of the item to complete the reordering for.
-   */
-  completeDraggingItem: (itemId: TreeViewItemId) => void;
-  /**
-   * Cancel the current reordering operation and reset the state.
-   */
-  cancelDraggingItem: () => 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: TreeViewItemId | 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 {TreeViewItemId} itemId The id of the item to check.
-   * @returns {boolean} `true` if the item can be reordered.
-   * @default () => true
-   */
-  isItemReorderable?: (itemId: TreeViewItemId) => boolean;
-  /**
-   * Used to determine if a given item can move to some new position.
-   * @param {object} parameters The params describing the item re-ordering.
-   * @param {TreeViewItemId} parameters.itemId The id of the item that is being moved to a new position.
-   * @param {TreeViewItemReorderPosition} parameters.oldPosition The old position of the item.
-   * @param {TreeViewItemReorderPosition} parameters.newPosition The new position of the item.
-   * @returns {boolean} `true` if the item can move to the new position.
-   */
-  canMoveItemToNewPosition?: (parameters: {
-    itemId: TreeViewItemId;
-    oldPosition: TreeViewItemReorderPosition;
-    newPosition: TreeViewItemReorderPosition;
-  }) => boolean;
-  /**
-   * Callback fired when a Tree Item is moved in the tree.
-   * @param {object} parameters The params describing the item re-ordering.
-   * @param {TreeViewItemId} parameters.itemId The id of the item moved.
-   * @param {TreeViewItemReorderPosition} parameters.oldPosition The old position of the item.
-   * @param {TreeViewItemReorderPosition} parameters.newPosition The new position of the item.
-   */
-  onItemPositionChange?: (parameters: {
-    itemId: TreeViewItemId;
-    oldPosition: TreeViewItemReorderPosition;
-    newPosition: TreeViewItemReorderPosition;
-  }) => void;
-}
-export type UseTreeViewItemsReorderingParametersWithDefaults = DefaultizedProps<UseTreeViewItemsReorderingParameters, 'itemsReordering'>;
-export interface UseTreeViewItemsReorderingState {
-  itemsReordering: {
-    isItemReorderable: (itemId: TreeViewItemId) => boolean;
-    currentReorder: {
-      draggedItemId: TreeViewItemId;
-      targetItemId: TreeViewItemId;
-      newPosition: TreeViewItemReorderPosition | null;
-      action: TreeViewItemsReorderingAction | null;
-    } | null;
-  };
-}
-export type UseTreeViewItemsReorderingSignature = TreeViewPluginSignature<{
-  params: UseTreeViewItemsReorderingParameters;
-  paramsWithDefaults: UseTreeViewItemsReorderingParametersWithDefaults;
-  instance: UseTreeViewItemsReorderingInstance;
-  state: UseTreeViewItemsReorderingState;
-  dependencies: [UseTreeViewItemsSignature];
-}>;

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

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

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

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

package/esm/internals/plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.d.ts

@@ -1,2 +0,0 @@
-import { TreeViewPlugin, UseTreeViewLazyLoadingSignature } from '@mui/x-tree-view/internals';
-export declare const useTreeViewLazyLoading: TreeViewPlugin<UseTreeViewLazyLoadingSignature>;

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

@@ -1,251 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useRefWithInit } from '@base-ui/utils/useRefWithInit';
-import { useStableCallback } from '@base-ui/utils/useStableCallback';
-import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
-import { itemsSelectors, expansionSelectors, selectionSelectors, lazyLoadingSelectors, useInstanceEventHandler, TREE_VIEW_ROOT_PARENT_ID } from '@mui/x-tree-view/internals';
-import { DataSourceCacheDefault } from '@mui/x-tree-view/utils';
-import { NestedDataManager } from "./utils.js";
-const INITIAL_STATE = {
-  loading: {},
-  errors: {}
-};
-export const useTreeViewLazyLoading = ({
-  instance,
-  params,
-  store
-}) => {
-  const nestedDataManager = useRefWithInit(() => new NestedDataManager(instance)).current;
-  const cache = useRefWithInit(() => params.dataSourceCache ?? new DataSourceCacheDefault({})).current;
-  const setDataSourceLoading = useStableCallback((itemId, isLoading) => {
-    if (!params.dataSource) {
-      return;
-    }
-    const itemIdWithDefault = itemId ?? TREE_VIEW_ROOT_PARENT_ID;
-    if (lazyLoadingSelectors.isItemLoading(store.state, itemIdWithDefault) === isLoading) {
-      return;
-    }
-    const loading = _extends({}, store.state.lazyLoading.dataSource.loading);
-    if (isLoading === false) {
-      delete loading[itemIdWithDefault];
-    } else {
-      loading[itemIdWithDefault] = isLoading;
-    }
-    store.set('lazyLoading', _extends({}, store.state.lazyLoading, {
-      dataSource: _extends({}, store.state.lazyLoading.dataSource, {
-        loading
-      })
-    }));
-  });
-  const setDataSourceError = useStableCallback((itemId, error) => {
-    if (!params.dataSource) {
-      return;
-    }
-    if (lazyLoadingSelectors.itemError(store.state, itemId) === error) {
-      return;
-    }
-    const stateId = itemId ?? TREE_VIEW_ROOT_PARENT_ID;
-    const errors = _extends({}, store.state.lazyLoading.dataSource.errors);
-    if (error === null && errors[stateId] !== undefined) {
-      delete errors[stateId];
-    } else {
-      errors[stateId] = error;
-    }
-    store.set('lazyLoading', _extends({}, store.state.lazyLoading, {
-      dataSource: _extends({}, store.state.lazyLoading.dataSource, {
-        errors
-      })
-    }));
-  });
-  const fetchItems = useStableCallback(async parentIds => nestedDataManager.queue(parentIds));
-  const fetchItemChildren = useStableCallback(async ({
-    itemId,
-    forceRefresh
-  }) => {
-    if (!params.dataSource) {
-      return;
-    }
-    const {
-      getChildrenCount,
-      getTreeItems
-    } = params.dataSource;
-    // clear the request if the item is not in the tree
-    if (itemId != null && !itemsSelectors.itemMeta(store.state, itemId)) {
-      nestedDataManager.clearPendingRequest(itemId);
-      return;
-    }
-
-    // reset the state if we are fetching the root items
-    if (itemId == null && lazyLoadingSelectors.dataSource(store.state) !== INITIAL_STATE) {
-      store.set('lazyLoading', _extends({}, store.state.lazyLoading, {
-        dataSource: INITIAL_STATE
-      }));
-    }
-    const cacheKey = itemId ?? TREE_VIEW_ROOT_PARENT_ID;
-    if (!forceRefresh) {
-      // reads from the value from the cache
-      const cachedData = cache.get(cacheKey);
-      if (cachedData !== undefined && cachedData !== -1) {
-        if (itemId != null) {
-          nestedDataManager.setRequestSettled(itemId);
-        }
-        instance.setItemChildren({
-          items: cachedData,
-          parentId: itemId,
-          getChildrenCount
-        });
-        instance.setDataSourceLoading(itemId, false);
-        return;
-      }
-
-      // set the item loading status to true
-      instance.setDataSourceLoading(itemId, true);
-      if (cachedData === -1) {
-        instance.removeChildren(itemId);
-      }
-    }
-
-    // reset existing error if any
-    if (lazyLoadingSelectors.itemError(store.state, itemId)) {
-      instance.setDataSourceError(itemId, null);
-    }
-    try {
-      let response;
-      if (itemId == null) {
-        response = await getTreeItems();
-      } else {
-        response = await getTreeItems(itemId);
-        nestedDataManager.setRequestSettled(itemId);
-      }
-      // save the response in the cache
-      cache.set(cacheKey, response);
-      // update the items in the state
-      instance.setItemChildren({
-        items: response,
-        parentId: itemId,
-        getChildrenCount
-      });
-    } catch (error) {
-      const childrenFetchError = error;
-      // set the item error in the state
-      instance.setDataSourceError(itemId, childrenFetchError);
-      if (forceRefresh) {
-        instance.removeChildren(itemId);
-      }
-    } finally {
-      // set the item loading status to false
-      instance.setDataSourceLoading(itemId, false);
-      if (itemId != null) {
-        nestedDataManager.setRequestSettled(itemId);
-      }
-    }
-  });
-  const updateItemChildren = useStableCallback(itemId => {
-    return instance.fetchItemChildren({
-      itemId,
-      forceRefresh: true
-    });
-  });
-  useInstanceEventHandler(instance, 'beforeItemToggleExpansion', async eventParameters => {
-    if (!params.dataSource || !eventParameters.shouldBeExpanded) {
-      return;
-    }
-
-    // prevent the default expansion behavior
-    eventParameters.isExpansionPrevented = true;
-    await instance.fetchItems([eventParameters.itemId]);
-    const hasError = lazyLoadingSelectors.itemHasError(store.state, eventParameters.itemId);
-    if (!hasError) {
-      instance.applyItemExpansion({
-        itemId: eventParameters.itemId,
-        shouldBeExpanded: true,
-        event: eventParameters.event
-      });
-      if (selectionSelectors.isItemSelected(store.state, eventParameters.itemId)) {
-        // make sure selection propagation works correctly
-        instance.setItemSelection({
-          event: eventParameters.event,
-          itemId: eventParameters.itemId,
-          keepExistingSelection: true,
-          shouldBeSelected: true
-        });
-      }
-    }
-  });
-  useLazyLoadOnMount({
-    instance,
-    params,
-    store
-  });
-  if (params.dataSource) {
-    instance.preventItemUpdates();
-  }
-  return {
-    instance: {
-      fetchItemChildren,
-      fetchItems,
-      updateItemChildren,
-      setDataSourceLoading,
-      setDataSourceError
-    },
-    publicAPI: {
-      updateItemChildren
-    }
-  };
-};
-useTreeViewLazyLoading.getInitialState = () => ({
-  lazyLoading: {
-    enabled: false,
-    dataSource: INITIAL_STATE
-  }
-});
-useTreeViewLazyLoading.params = {
-  dataSource: true,
-  dataSourceCache: true
-};
-function useLazyLoadOnMount({
-  instance,
-  params,
-  store
-}) {
-  const firstRenderRef = React.useRef(true);
-  useEnhancedEffect(() => {
-    if (!params.dataSource || !firstRenderRef.current) {
-      return;
-    }
-    firstRenderRef.current = false;
-    store.set('lazyLoading', _extends({}, store.state.lazyLoading, {
-      enabled: true
-    }));
-    async function fetchAllExpandedItems() {
-      async function fetchChildrenIfExpanded(parentIds) {
-        const expandedItems = parentIds.filter(id => expansionSelectors.isItemExpanded(store.state, id));
-        if (expandedItems.length > 0) {
-          const itemsToLazyLoad = expandedItems.filter(id => itemsSelectors.itemOrderedChildrenIds(store.state, id).length === 0);
-          if (itemsToLazyLoad.length > 0) {
-            await instance.fetchItems(itemsToLazyLoad);
-          }
-          const childrenIds = expandedItems.flatMap(id => itemsSelectors.itemOrderedChildrenIds(store.state, id));
-          await fetchChildrenIfExpanded(childrenIds);
-        }
-      }
-      if (params.items.length) {
-        const newlyExpandableItems = getExpandableItemsFromDataSource(store, params.dataSource);
-        if (newlyExpandableItems.length > 0) {
-          instance.addExpandableItems(newlyExpandableItems);
-        }
-      } else {
-        await instance.fetchItemChildren({
-          itemId: null
-        });
-      }
-      await fetchChildrenIfExpanded(itemsSelectors.itemOrderedChildrenIds(store.state, null));
-    }
-    fetchAllExpandedItems();
-  }, [instance, params.items, params.dataSource, store]);
-}
-function getExpandableItemsFromDataSource(store, dataSource) {
-  return Object.values(store.state.items.itemMetaLookup).filter(itemMeta => !itemMeta.expandable && dataSource.getChildrenCount(store.state.items.itemModelLookup[itemMeta.id]) !== 0).map(item => item.id);
-}

package/internals/index.d.ts

@@ -1 +0,0 @@
-export type { UseTreeViewItemsReorderingSignature } from "./plugins/useTreeViewItemsReordering/index.js";

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

@@ -1,3 +0,0 @@
-export { useTreeViewItemsReordering } from "./useTreeViewItemsReordering.js";
-export type { UseTreeViewItemsReorderingSignature, UseTreeViewItemsReorderingParameters, UseTreeViewItemsReorderingParametersWithDefaults, TreeViewItemReorderPosition } from "./useTreeViewItemsReordering.types.js";
-export { itemsReorderingSelectors } from "./useTreeViewItemsReordering.selectors.js";

package/internals/plugins/useTreeViewItemsReordering/index.js

@@ -1,19 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "itemsReorderingSelectors", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewItemsReordering2.itemsReorderingSelectors;
-  }
-});
-Object.defineProperty(exports, "useTreeViewItemsReordering", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewItemsReordering.useTreeViewItemsReordering;
-  }
-});
-var _useTreeViewItemsReordering = require("./useTreeViewItemsReordering");
-var _useTreeViewItemsReordering2 = require("./useTreeViewItemsReordering.selectors");

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

@@ -1,3 +0,0 @@
-import { TreeViewPlugin } from '@mui/x-tree-view/internals';
-import { UseTreeViewItemsReorderingSignature } from "./useTreeViewItemsReordering.types.js";
-export declare const useTreeViewItemsReordering: TreeViewPlugin<UseTreeViewItemsReorderingSignature>;

package/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.js

@@ -1,205 +0,0 @@
-"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 _useIsoLayoutEffect = require("@base-ui/utils/useIsoLayoutEffect");
-var _internals = require("@mui/x-tree-view/internals");
-var _useTreeViewItemsReordering = require("./useTreeViewItemsReordering.utils");
-var _itemPlugin = require("./itemPlugin");
-var _useTreeViewItemsReordering2 = require("./useTreeViewItemsReordering.selectors");
-const useTreeViewItemsReordering = ({
-  params,
-  store
-}) => {
-  const getDroppingTargetValidActions = React.useCallback(itemId => {
-    const currentReorder = _useTreeViewItemsReordering2.itemsReorderingSelectors.currentReorder(store.state);
-    if (!currentReorder) {
-      throw new Error('There is no ongoing reordering.');
-    }
-    if (itemId === currentReorder.draggedItemId) {
-      return {};
-    }
-    const canMoveItemToNewPosition = params.canMoveItemToNewPosition;
-    const targetItemMeta = _internals.itemsSelectors.itemMeta(store.state, itemId);
-    const targetItemIndex = _internals.itemsSelectors.itemIndex(store.state, targetItemMeta.id);
-    const draggedItemMeta = _internals.itemsSelectors.itemMeta(store.state, currentReorder.draggedItemId);
-    const draggedItemIndex = _internals.itemsSelectors.itemIndex(store.state, draggedItemMeta.id);
-    const isTargetLastSibling = targetItemIndex === _internals.itemsSelectors.itemOrderedChildrenIds(store.state, 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: _internals.itemsSelectors.itemOrderedChildrenIds(store.state, 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 => {
-    const isItemBeingEdited = _internals.labelSelectors.isItemBeingEdited(store.state, itemId);
-    if (isItemBeingEdited) {
-      return;
-    }
-    store.set('itemsReordering', (0, _extends2.default)({}, store.state.itemsReordering, {
-      currentReorder: {
-        targetItemId: itemId,
-        draggedItemId: itemId,
-        action: null,
-        newPosition: null
-      }
-    }));
-  }, [store]);
-  const cancelDraggingItem = React.useCallback(() => {
-    const currentReorder = _useTreeViewItemsReordering2.itemsReorderingSelectors.currentReorder(store.state);
-    if (currentReorder == null) {
-      return;
-    }
-    store.set('itemsReordering', (0, _extends2.default)({}, store.state.itemsReordering, {
-      currentReorder: null
-    }));
-  }, [store]);
-  const completeDraggingItem = React.useCallback(itemId => {
-    const currentReorder = _useTreeViewItemsReordering2.itemsReorderingSelectors.currentReorder(store.state);
-    if (currentReorder == null || currentReorder.draggedItemId !== itemId) {
-      return;
-    }
-    if (currentReorder.draggedItemId === currentReorder.targetItemId || currentReorder.action == null || currentReorder.newPosition == null) {
-      store.set('itemsReordering', (0, _extends2.default)({}, store.state.itemsReordering, {
-        currentReorder: null
-      }));
-      return;
-    }
-    const draggedItemMeta = _internals.itemsSelectors.itemMeta(store.state, currentReorder.draggedItemId);
-    const oldPosition = {
-      parentId: draggedItemMeta.parentId,
-      index: _internals.itemsSelectors.itemIndex(store.state, draggedItemMeta.id)
-    };
-    const newPosition = currentReorder.newPosition;
-    store.update({
-      itemsReordering: (0, _extends2.default)({}, store.state.itemsReordering, {
-        currentReorder: null
-      }),
-      items: (0, _useTreeViewItemsReordering.moveItemInTree)({
-        itemToMoveId: itemId,
-        newPosition,
-        oldPosition,
-        prevState: store.state.items
-      })
-    });
-    const onItemPositionChange = params.onItemPositionChange;
-    onItemPositionChange?.({
-      itemId,
-      newPosition,
-      oldPosition
-    });
-  }, [store, params.onItemPositionChange]);
-  const setDragTargetItem = React.useCallback(({
-    itemId,
-    validActions,
-    targetHeight,
-    cursorY,
-    cursorX,
-    contentElement
-  }) => {
-    const prevItemReorder = store.state.itemsReordering.currentReorder;
-    if (prevItemReorder == null || (0, _useTreeViewItemsReordering.isAncestor)(store, itemId, prevItemReorder.draggedItemId)) {
-      return;
-    }
-    const action = (0, _useTreeViewItemsReordering.chooseActionToApply)({
-      itemChildrenIndentation: params.itemChildrenIndentation,
-      validActions,
-      targetHeight,
-      targetDepth: store.state.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;
-    }
-    store.set('itemsReordering', (0, _extends2.default)({}, store.state.itemsReordering, {
-      currentReorder: (0, _extends2.default)({}, prevItemReorder, {
-        targetItemId: itemId,
-        newPosition,
-        action
-      })
-    }));
-  }, [store, params.itemChildrenIndentation]);
-  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => {
-    store.set('itemsReordering', (0, _extends2.default)({}, store.state.itemsReordering, {
-      isItemReorderable: params.itemsReordering ? params.isItemReorderable ?? (() => true) : () => false
-    }));
-  }, [store, params.itemsReordering, params.isItemReorderable]);
-  return {
-    instance: {
-      getDroppingTargetValidActions,
-      startDraggingItem,
-      cancelDraggingItem,
-      completeDraggingItem,
-      setDragTargetItem
-    }
-  };
-};
-exports.useTreeViewItemsReordering = useTreeViewItemsReordering;
-useTreeViewItemsReordering.itemPlugin = _itemPlugin.useTreeViewItemsReorderingItemPlugin;
-useTreeViewItemsReordering.applyDefaultValuesToParams = ({
-  params
-}) => (0, _extends2.default)({}, 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/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.selectors.d.ts

@@ -1,30 +0,0 @@
-import { TreeViewState } from '@mui/x-tree-view/internals';
-import { TreeViewItemId } from '@mui/x-tree-view/models';
-import { UseTreeViewItemsReorderingSignature } from "./useTreeViewItemsReordering.types.js";
-export declare const itemsReorderingSelectors: {
-  /**
-   * Gets the properties of the current reordering.
-   */
-  currentReorder: (state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => {
-    draggedItemId: TreeViewItemId;
-    targetItemId: TreeViewItemId;
-    newPosition: import("./useTreeViewItemsReordering.types.js").TreeViewItemReorderPosition | null;
-    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction | null;
-  } | null;
-  /**
-   * Gets the properties of the dragged item.
-   */
-  draggedItemProperties: (args_0: 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<{}>, itemId: string) => {
-    newPosition: import("./useTreeViewItemsReordering.types.js").TreeViewItemReorderPosition | null;
-    action: import("@mui/x-tree-view").TreeViewItemsReorderingAction;
-    targetDepth: number;
-  } | null;
-  /**
-   * Checks whether an item is being dragged.
-   */
-  isDragging: (state: TreeViewState<[UseTreeViewItemsReorderingSignature]>) => boolean;
-  /**
-   * Checks whether an item can be reordered.
-   */
-  canItemBeReordered: (args_0: import("@mui/x-tree-view/internals/corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewItemsReordering.types.js").UseTreeViewItemsReorderingState & Partial<{}>, itemId: string) => boolean;
-};