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

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

@@ -0,0 +1,6 @@
+import { TreeViewItemsReorderingAction } from '@mui/x-tree-view/models';
+export interface TreeViewItemReorderPosition {
+  parentId: string | null;
+  index: number;
+}
+export type TreeViewItemItemReorderingValidActions = { [key in TreeViewItemsReorderingAction]?: TreeViewItemReorderPosition };

package/{internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.utils.d.ts → esm/internals/plugins/itemsReordering/utils.d.ts}

@@ -1,10 +1,10 @@
-import { TreeViewUsedStore, UseTreeViewItemsState } from '@mui/x-tree-view/internals';
-import { TreeViewItemId, TreeViewItemsReorderingAction } from '@mui/x-tree-view/models';
-import { TreeViewItemItemReorderingValidActions, TreeViewItemReorderPosition, UseTreeViewItemsReorderingSignature } from "./useTreeViewItemsReordering.types.js";
+import { TreeViewItemId, TreeViewItemsReorderingAction, TreeViewValidItem } from '@mui/x-tree-view/models';
+import { TreeViewItemItemReorderingValidActions, TreeViewItemReorderPosition } from "./types.js";
+import { RichTreeViewProState, RichTreeViewProStore } from "../../RichTreeViewProStore/index.js";
 /**
  * Checks if the item with the id itemIdB is an ancestor of the item with the id itemIdA.
  */
-export declare const isAncestor: (store: TreeViewUsedStore<UseTreeViewItemsReorderingSignature>, itemIdA: string, itemIdB: string) => boolean;
+export declare const isAncestor: (store: RichTreeViewProStore<any, any>, itemIdA: string, itemIdB: string) => boolean;
 interface GetNewPositionParameters {
   itemChildrenIndentation: string | number;
   validActions: TreeViewItemItemReorderingValidActions;
@@ -23,7 +23,7 @@ export declare const chooseActionToApply: ({
   cursorY,
   contentElement
 }: GetNewPositionParameters) => TreeViewItemsReorderingAction | null;
-export declare const moveItemInTree: <R extends {}>({
+export declare const moveItemInTree: <R extends TreeViewValidItem<R>>({
   itemToMoveId,
   oldPosition,
   newPosition,
@@ -32,6 +32,6 @@ export declare const moveItemInTree: <R extends {}>({
   itemToMoveId: TreeViewItemId;
   oldPosition: TreeViewItemReorderPosition;
   newPosition: TreeViewItemReorderPosition;
-  prevState: UseTreeViewItemsState<R>["items"];
-}) => UseTreeViewItemsState<R>["items"];
+  prevState: RichTreeViewProState<R, any>;
+}) => Pick<RichTreeViewProState<R, any>, "itemOrderedChildrenIdsLookup" | "itemChildrenIndexesLookup" | "itemMetaLookup">;
 export {};

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

@@ -150,9 +150,9 @@ export const moveItemInTree = ({
     itemOrderedChildrenIds[itemId]?.forEach(childId => updateItemDepth(childId, depth + 1));
   };
   itemOrderedChildrenIds[itemToMoveId]?.forEach(childId => updateItemDepth(childId, itemToMoveDepth + 1));
-  return _extends({}, prevState, {
+  return {
     itemOrderedChildrenIdsLookup: itemOrderedChildrenIds,
     itemChildrenIndexesLookup: itemChildrenIndexes,
     itemMetaLookup
-  });
+  };
 };

package/esm/internals/plugins/lazyLoading/TreeViewLazyLoadingPlugin.d.ts

@@ -0,0 +1,51 @@
+import { TreeViewItemId } from '@mui/x-tree-view/models';
+import { RichTreeViewProStore } from "../../RichTreeViewProStore/RichTreeViewProStore.js";
+export declare const TREE_VIEW_LAZY_LOADED_ITEMS_INITIAL_STATE: {
+  loading: {};
+  errors: {};
+};
+export declare class TreeViewLazyLoadingPlugin {
+  private store;
+  private nestedDataManager;
+  private cache;
+  constructor(store: RichTreeViewProStore<any, any>);
+  private init;
+  private handleBeforeItemToggleExpansion;
+  private setItemLoading;
+  private setItemError;
+  buildPublicAPI: () => {
+    updateItemChildren: (itemId: TreeViewItemId | null) => Promise<void>;
+  };
+  /**
+   * Method used for fetching multiple items concurrently.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @param {TreeViewItemId[]} parentIds The ids of the items to fetch the children of.
+   * @returns {Promise<void>} The promise resolved when the items are fetched.
+   */
+  fetchItems: (parentIds: TreeViewItemId[]) => Promise<void>;
+  /**
+   * Method used for updating an item's children.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @param {TreeViewItemId | null} itemId The id of the item to update the children of. If null is passed, it will update the root's children.
+   * @returns {Promise<void>} The promise resolved when the items are fetched.
+   */
+  updateItemChildren: (itemId: TreeViewItemId | null) => Promise<void>;
+  /**
+   * Method used for fetching an item's children.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @param {object} parameters The parameters of the method.
+   * @param {TreeViewItemId} parameters.itemId The The id of the item to fetch the children of.
+   * @param {boolean} [parameters.forceRefresh] Whether to force a refresh of the children when the cache already contains some data.
+   * @returns {Promise<void>} The promise resolved when the items are fetched.
+   */
+  fetchItemChildren: ({
+    itemId,
+    forceRefresh
+  }: {
+    itemId: TreeViewItemId | null;
+    forceRefresh?: boolean;
+  }) => Promise<void>;
+}

package/esm/internals/plugins/lazyLoading/TreeViewLazyLoadingPlugin.js

@@ -0,0 +1,230 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { itemsSelectors, lazyLoadingSelectors, TREE_VIEW_ROOT_PARENT_ID, expansionSelectors, selectionSelectors } from '@mui/x-tree-view/internals';
+import { DataSourceCacheDefault } from '@mui/x-tree-view/utils';
+import { NestedDataManager } from "./utils.js";
+export const TREE_VIEW_LAZY_LOADED_ITEMS_INITIAL_STATE = {
+  loading: {},
+  errors: {}
+};
+export class TreeViewLazyLoadingPlugin {
+  nestedDataManager = (() => new NestedDataManager(this))();
+  constructor(store) {
+    this.store = store;
+    this.cache = store.parameters.dataSourceCache ?? new DataSourceCacheDefault({});
+    if (store.parameters.dataSource != null) {
+      this.init();
+      store.subscribeEvent('beforeItemToggleExpansion', this.handleBeforeItemToggleExpansion);
+    }
+  }
+  init = () => {
+    const store = this.store;
+    // eslint-disable-next-line consistent-this
+    const plugin = this;
+    const fetchAllExpandedItems = async () => {
+      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 plugin.fetchItems(itemsToLazyLoad);
+          }
+          const childrenIds = expandedItems.flatMap(id => itemsSelectors.itemOrderedChildrenIds(store.state, id));
+          await fetchChildrenIfExpanded(childrenIds);
+        }
+      }
+      if (store.parameters.items.length) {
+        const newlyExpandableItems = getExpandableItemsFromDataSource(store, store.parameters.dataSource);
+        if (newlyExpandableItems.length > 0) {
+          store.expansion.addExpandableItems(newlyExpandableItems);
+        }
+      } else {
+        await plugin.fetchItemChildren({
+          itemId: null
+        });
+      }
+      await fetchChildrenIfExpanded(itemsSelectors.itemOrderedChildrenIds(store.state, null));
+    };
+    fetchAllExpandedItems();
+  };
+  handleBeforeItemToggleExpansion = async (eventParameters, event) => {
+    if (!this.store.parameters.dataSource || !eventParameters.shouldBeExpanded) {
+      return;
+    }
+
+    // prevent the default expansion behavior
+    eventParameters.isExpansionPrevented = true;
+    await this.fetchItems([eventParameters.itemId]);
+    const hasError = lazyLoadingSelectors.itemHasError(this.store.state, eventParameters.itemId);
+    if (!hasError) {
+      this.store.expansion.applyItemExpansion({
+        itemId: eventParameters.itemId,
+        shouldBeExpanded: true,
+        event
+      });
+      if (selectionSelectors.isItemSelected(this.store.state, eventParameters.itemId)) {
+        // make sure selection propagation works correctly
+        this.store.selection.setItemSelection({
+          event,
+          itemId: eventParameters.itemId,
+          keepExistingSelection: true,
+          shouldBeSelected: true
+        });
+      }
+    }
+  };
+  setItemLoading = (itemId, isLoading) => {
+    if (!this.store.parameters.dataSource || !this.store.state.lazyLoadedItems) {
+      return;
+    }
+    if (lazyLoadingSelectors.isItemLoading(this.store.state, itemId) === isLoading) {
+      return;
+    }
+    const itemIdWithDefault = itemId ?? TREE_VIEW_ROOT_PARENT_ID;
+    const loading = _extends({}, this.store.state.lazyLoadedItems.loading);
+    if (isLoading === false) {
+      delete loading[itemIdWithDefault];
+    } else {
+      loading[itemIdWithDefault] = isLoading;
+    }
+    this.store.set('lazyLoadedItems', _extends({}, this.store.state.lazyLoadedItems, {
+      loading
+    }));
+  };
+  setItemError = (itemId, error) => {
+    if (!this.store.parameters.dataSource || !this.store.state.lazyLoadedItems) {
+      return;
+    }
+    if (lazyLoadingSelectors.itemError(this.store.state, itemId) === error) {
+      return;
+    }
+    const itemIdWithDefault = itemId ?? TREE_VIEW_ROOT_PARENT_ID;
+    const errors = _extends({}, this.store.state.lazyLoadedItems.errors);
+    if (error === null && errors[itemIdWithDefault] !== undefined) {
+      delete errors[itemIdWithDefault];
+    } else {
+      errors[itemIdWithDefault] = error;
+    }
+    this.store.set('lazyLoadedItems', _extends({}, this.store.state.lazyLoadedItems, {
+      errors
+    }));
+  };
+  buildPublicAPI = () => {
+    return {
+      updateItemChildren: this.updateItemChildren
+    };
+  };
+
+  /**
+   * Method used for fetching multiple items concurrently.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @param {TreeViewItemId[]} parentIds The ids of the items to fetch the children of.
+   * @returns {Promise<void>} The promise resolved when the items are fetched.
+   */
+  fetchItems = parentIds => this.nestedDataManager.queue(parentIds);
+
+  /**
+   * Method used for updating an item's children.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @param {TreeViewItemId | null} itemId The id of the item to update the children of. If null is passed, it will update the root's children.
+   * @returns {Promise<void>} The promise resolved when the items are fetched.
+   */
+  updateItemChildren = itemId => this.fetchItemChildren({
+    itemId,
+    forceRefresh: true
+  });
+
+  /**
+   * Method used for fetching an item's children.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @param {object} parameters The parameters of the method.
+   * @param {TreeViewItemId} parameters.itemId The The id of the item to fetch the children of.
+   * @param {boolean} [parameters.forceRefresh] Whether to force a refresh of the children when the cache already contains some data.
+   * @returns {Promise<void>} The promise resolved when the items are fetched.
+   */
+  fetchItemChildren = async ({
+    itemId,
+    forceRefresh
+  }) => {
+    if (!this.store.parameters.dataSource) {
+      return;
+    }
+    const {
+      getChildrenCount,
+      getTreeItems
+    } = this.store.parameters.dataSource;
+    // clear the request if the item is not in the tree
+    if (itemId != null && !itemsSelectors.itemMeta(this.store.state, itemId)) {
+      this.nestedDataManager.clearPendingRequest(itemId);
+      return;
+    }
+
+    // reset the state if we are fetching the root items
+    if (itemId == null && !lazyLoadingSelectors.isEmpty(this.store.state)) {
+      this.store.set('lazyLoadedItems', TREE_VIEW_LAZY_LOADED_ITEMS_INITIAL_STATE);
+    }
+    const cacheKey = itemId ?? TREE_VIEW_ROOT_PARENT_ID;
+    if (!forceRefresh) {
+      // reads from the value from the cache
+      const cachedData = this.cache.get(cacheKey);
+      if (cachedData !== undefined && cachedData !== -1) {
+        if (itemId != null) {
+          this.nestedDataManager.setRequestSettled(itemId);
+        }
+        this.store.items.setItemChildren({
+          items: cachedData,
+          parentId: itemId,
+          getChildrenCount
+        });
+        this.setItemLoading(itemId, false);
+        return;
+      }
+
+      // set the item loading status to true
+      this.setItemLoading(itemId, true);
+      if (cachedData === -1) {
+        this.store.items.removeChildren(itemId);
+      }
+    }
+
+    // reset existing error if any
+    if (lazyLoadingSelectors.itemError(this.store.state, itemId)) {
+      this.setItemError(itemId, null);
+    }
+    try {
+      let response;
+      if (itemId == null) {
+        response = await getTreeItems();
+      } else {
+        response = await getTreeItems(itemId);
+        this.nestedDataManager.setRequestSettled(itemId);
+      }
+      // save the response in the cache
+      this.cache.set(cacheKey, response);
+      // update the items in the state
+      this.store.items.setItemChildren({
+        items: response,
+        parentId: itemId,
+        getChildrenCount
+      });
+    } catch (error) {
+      const childrenFetchError = error;
+      // set the item error in the state
+      this.setItemError(itemId, childrenFetchError);
+      if (forceRefresh) {
+        this.store.items.removeChildren(itemId);
+      }
+    } finally {
+      // set the item loading status to false
+      this.setItemLoading(itemId, false);
+      if (itemId != null) {
+        this.nestedDataManager.setRequestSettled(itemId);
+      }
+    }
+  };
+}
+function getExpandableItemsFromDataSource(store, dataSource) {
+  return Object.values(store.state.itemMetaLookup).filter(itemMeta => !itemMeta.expandable && dataSource.getChildrenCount(store.state.itemModelLookup[itemMeta.id]) !== 0).map(item => item.id);
+}

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

@@ -0,0 +1,2 @@
+export * from "./TreeViewLazyLoadingPlugin.js";
+export * from "./types.js";

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

@@ -0,0 +1,2 @@
+export * from "./TreeViewLazyLoadingPlugin.js";
+export * from "./types.js";

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

@@ -0,0 +1,21 @@
+import { TreeViewItemId } from '@mui/x-tree-view/models';
+export type DataSource<R extends {}> = {
+  /**
+   * Used to determine the number of children the item has.
+   * Only relevant for lazy-loaded trees.
+   *
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {number} The number of children.
+   */
+  getChildrenCount: (item: R) => number;
+  /**
+   * Method used for fetching the items.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @template R
+   * @param {TreeViewItemId} parentId The id of the item the children belong to.
+   * @returns { Promise<R[]>} The children of the item.
+   */
+  getTreeItems: (parentId?: TreeViewItemId) => Promise<R[]>;
+};

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

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

package/{internals/plugins/useTreeViewLazyLoading → esm/internals/plugins/lazyLoading}/utils.d.ts

@@ -1,15 +1,11 @@
-import { TreeViewInstance, UseTreeViewLazyLoadingSignature } from '@mui/x-tree-view/internals';
 import { TreeViewItemId } from '@mui/x-tree-view/models';
+import { TreeViewLazyLoadingPlugin } from "./TreeViewLazyLoadingPlugin.js";
 export declare enum RequestStatus {
   QUEUED = 0,
   PENDING = 1,
   SETTLED = 2,
   UNKNOWN = 3,
 }
-/**
- * Plugins that the `NestedDataManager` class can use if they are present, but are not required.
- */
-export type NestedDataManagerOptionalPlugins = readonly [];
 /**
  * Fetches row children from the server with option to limit the number of concurrent requests
  * Determines the status of a request based on the enum `RequestStatus`
@@ -19,9 +15,9 @@ export declare class NestedDataManager {
   private pendingRequests;
   private queuedRequests;
   private settledRequests;
-  private instance;
+  private lazyLoadingPlugin;
   private maxConcurrentRequests;
-  constructor(instance: TreeViewInstance<[UseTreeViewLazyLoadingSignature]>, maxConcurrentRequests?: number);
+  constructor(lazyLoadingPlugin: TreeViewLazyLoadingPlugin, maxConcurrentRequests?: number);
   private processQueue;
   queue: (ids: TreeViewItemId[]) => Promise<void>;
   setRequestSettled: (id: TreeViewItemId) => Promise<void>;

package/esm/internals/plugins/{useTreeViewLazyLoading → lazyLoading}/utils.js

@@ -7,14 +7,6 @@ export let RequestStatus = /*#__PURE__*/function (RequestStatus) {
   return RequestStatus;
 }({});
 
-/**
- * Plugins that need to be present in the Tree View in order for the `NestedDataManager` class to work correctly.
- */
-
-/**
- * Plugins that the `NestedDataManager` class can use if they are present, but are not required.
- */
-
 /**
  * Fetches row children from the server with option to limit the number of concurrent requests
  * Determines the status of a request based on the enum `RequestStatus`
@@ -24,8 +16,8 @@ export class NestedDataManager {
   pendingRequests = (() => new Set())();
   queuedRequests = (() => new Set())();
   settledRequests = (() => new Set())();
-  constructor(instance, maxConcurrentRequests = MAX_CONCURRENT_REQUESTS) {
-    this.instance = instance;
+  constructor(lazyLoadingPlugin, maxConcurrentRequests = MAX_CONCURRENT_REQUESTS) {
+    this.lazyLoadingPlugin = lazyLoadingPlugin;
     this.maxConcurrentRequests = maxConcurrentRequests;
   }
   processQueue = async () => {
@@ -42,7 +34,7 @@ export class NestedDataManager {
       const id = fetchQueue[i];
       this.queuedRequests.delete(id);
       this.pendingRequests.add(id);
-      fetchPromises.push(this.instance.fetchItemChildren({
+      fetchPromises.push(this.lazyLoadingPlugin.fetchItemChildren({
         itemId: id
       }));
     }

package/hooks/useRichTreeViewProApiRef.d.ts

@@ -1,8 +1,8 @@
 import * as React from 'react';
 import { TreeViewPublicAPI } from '@mui/x-tree-view/internals';
 import { TreeViewDefaultItemModelProperties, TreeViewValidItem } from '@mui/x-tree-view/models';
-import { RichTreeViewProPluginSignatures } from "../RichTreeViewPro/index.js";
+import { RichTreeViewProStore } from "../internals/RichTreeViewProStore/index.js";
 /**
  * Creates the ref to pass to the `apiRef` prop of the `RichTreeViewPro` component.
  */
-export declare function useRichTreeViewProApiRef<R extends TreeViewValidItem<R> = TreeViewDefaultItemModelProperties>(): React.RefObject<TreeViewPublicAPI<RichTreeViewProPluginSignatures> | undefined>;
+export declare function useRichTreeViewProApiRef<R extends TreeViewValidItem<R> = TreeViewDefaultItemModelProperties>(): React.RefObject<TreeViewPublicAPI<RichTreeViewProStore<R, boolean>> | undefined>;

package/index.d.ts

@@ -6,7 +6,6 @@ export * from '@mui/x-tree-view/TreeItemIcon';
 export * from '@mui/x-tree-view/TreeItemProvider';
 export * from '@mui/x-tree-view/TreeItemDragAndDropOverlay';
 export * from '@mui/x-tree-view/TreeItemLabelInput';
-export { unstable_resetCleanupTracking } from '@mui/x-tree-view/internals';
 export * from '@mui/x-tree-view/models';
 export * from '@mui/x-tree-view/icons';
 export * from '@mui/x-tree-view/hooks';

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-tree-view-pro v8.23.0
+ * @mui/x-tree-view-pro v8.24.0
  *
  * @license SEE LICENSE IN LICENSE
  * This source code is licensed under the SEE LICENSE IN LICENSE license found in the
@@ -10,19 +10,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _exportNames = {
-  unstable_resetCleanupTracking: true
-};
-Object.defineProperty(exports, "unstable_resetCleanupTracking", {
-  enumerable: true,
-  get: function () {
-    return _internals.unstable_resetCleanupTracking;
-  }
-});
 var _SimpleTreeView = require("@mui/x-tree-view/SimpleTreeView");
 Object.keys(_SimpleTreeView).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _SimpleTreeView[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -34,7 +24,6 @@ Object.keys(_SimpleTreeView).forEach(function (key) {
 var _RichTreeViewPro = require("./RichTreeViewPro");
 Object.keys(_RichTreeViewPro).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _RichTreeViewPro[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -46,7 +35,6 @@ Object.keys(_RichTreeViewPro).forEach(function (key) {
 var _TreeItem = require("@mui/x-tree-view/TreeItem");
 Object.keys(_TreeItem).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _TreeItem[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -58,7 +46,6 @@ Object.keys(_TreeItem).forEach(function (key) {
 var _useTreeItem = require("@mui/x-tree-view/useTreeItem");
 Object.keys(_useTreeItem).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _useTreeItem[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -70,7 +57,6 @@ Object.keys(_useTreeItem).forEach(function (key) {
 var _TreeItemIcon = require("@mui/x-tree-view/TreeItemIcon");
 Object.keys(_TreeItemIcon).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _TreeItemIcon[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -82,7 +68,6 @@ Object.keys(_TreeItemIcon).forEach(function (key) {
 var _TreeItemProvider = require("@mui/x-tree-view/TreeItemProvider");
 Object.keys(_TreeItemProvider).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _TreeItemProvider[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -94,7 +79,6 @@ Object.keys(_TreeItemProvider).forEach(function (key) {
 var _TreeItemDragAndDropOverlay = require("@mui/x-tree-view/TreeItemDragAndDropOverlay");
 Object.keys(_TreeItemDragAndDropOverlay).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _TreeItemDragAndDropOverlay[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -106,7 +90,6 @@ Object.keys(_TreeItemDragAndDropOverlay).forEach(function (key) {
 var _TreeItemLabelInput = require("@mui/x-tree-view/TreeItemLabelInput");
 Object.keys(_TreeItemLabelInput).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _TreeItemLabelInput[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -115,11 +98,9 @@ Object.keys(_TreeItemLabelInput).forEach(function (key) {
     }
   });
 });
-var _internals = require("@mui/x-tree-view/internals");
 var _models = require("@mui/x-tree-view/models");
 Object.keys(_models).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _models[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -131,7 +112,6 @@ Object.keys(_models).forEach(function (key) {
 var _icons = require("@mui/x-tree-view/icons");
 Object.keys(_icons).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _icons[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -143,7 +123,6 @@ Object.keys(_icons).forEach(function (key) {
 var _hooks = require("@mui/x-tree-view/hooks");
 Object.keys(_hooks).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _hooks[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -155,7 +134,6 @@ Object.keys(_hooks).forEach(function (key) {
 var _hooks2 = require("./hooks");
 Object.keys(_hooks2).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _hooks2[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,

package/internals/RichTreeViewProStore/RichTreeViewProStore.d.ts

@@ -0,0 +1,49 @@
+import { ExtendableRichTreeViewStore } from '@mui/x-tree-view/internals';
+import { TreeViewValidItem } from '@mui/x-tree-view/models';
+import { RichTreeViewProStoreParameters, RichTreeViewProState } from "./RichTreeViewProStore.types.js";
+import { TreeViewLazyLoadingPlugin } from "../plugins/lazyLoading/index.js";
+import { TreeViewItemsReorderingPlugin } from "../plugins/itemsReordering/index.js";
+export declare class RichTreeViewProStore<R extends TreeViewValidItem<R>, Multiple extends boolean | undefined> extends ExtendableRichTreeViewStore<R, Multiple, RichTreeViewProState<R, Multiple>, RichTreeViewProStoreParameters<R, Multiple>> {
+  lazyLoading: TreeViewLazyLoadingPlugin;
+  itemsReordering: TreeViewItemsReorderingPlugin;
+  constructor(parameters: RichTreeViewProStoreParameters<R, Multiple>);
+  buildPublicAPI(): {
+    updateItemChildren: (itemId: import("@mui/x-tree-view").TreeViewItemId | null) => Promise<void>;
+    setEditedItem: (itemId: import("@mui/x-tree-view").TreeViewItemId | null) => void;
+    updateItemLabel: (itemId: import("@mui/x-tree-view").TreeViewItemId, label: string) => void;
+    setItemSelection: ({
+      itemId,
+      event,
+      keepExistingSelection,
+      shouldBeSelected
+    }: {
+      itemId: string;
+      event?: React.SyntheticEvent | null;
+      shouldBeSelected?: boolean;
+      keepExistingSelection?: boolean;
+    }) => void;
+    isItemExpanded: (itemId: import("@mui/x-tree-view").TreeViewItemId) => boolean;
+    setItemExpansion: ({
+      itemId,
+      event,
+      shouldBeExpanded
+    }: {
+      itemId: import("@mui/x-tree-view").TreeViewItemId;
+      event?: React.SyntheticEvent | null;
+      shouldBeExpanded?: boolean;
+    }) => void;
+    focusItem: (event: React.SyntheticEvent | null, itemId: import("@mui/x-tree-view").TreeViewItemId) => void;
+    getItem: (itemId: import("@mui/x-tree-view").TreeViewItemId) => R;
+    getItemDOMElement: (itemId: import("@mui/x-tree-view").TreeViewItemId) => HTMLElement | null;
+    getItemOrderedChildrenIds: (itemId: import("@mui/x-tree-view").TreeViewItemId | null) => import("@mui/x-tree-view").TreeViewItemId[];
+    getItemTree: () => R[];
+    getParentId: (itemId: import("@mui/x-tree-view").TreeViewItemId) => import("@mui/x-tree-view").TreeViewItemId | null;
+    setIsItemDisabled: ({
+      itemId,
+      shouldBeDisabled
+    }: {
+      itemId: import("@mui/x-tree-view").TreeViewItemId;
+      shouldBeDisabled?: boolean;
+    }) => void;
+  };
+}

package/internals/RichTreeViewProStore/RichTreeViewProStore.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RichTreeViewProStore = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _internals = require("@mui/x-tree-view/internals");
+var _lazyLoading = require("../plugins/lazyLoading");
+var _itemsReordering = require("../plugins/itemsReordering");
+var _RichTreeViewProStore = require("./RichTreeViewProStore.utils");
+class RichTreeViewProStore extends _internals.ExtendableRichTreeViewStore {
+  itemsReordering = new _itemsReordering.TreeViewItemsReorderingPlugin(this);
+  constructor(parameters) {
+    super(parameters, 'RichTreeViewPro', _RichTreeViewProStore.parametersToStateMapper);
+    this.lazyLoading = new _lazyLoading.TreeViewLazyLoadingPlugin(this);
+  }
+  buildPublicAPI() {
+    return (0, _extends2.default)({}, super.buildPublicAPI(), this.lazyLoading.buildPublicAPI());
+  }
+}
+exports.RichTreeViewProStore = RichTreeViewProStore;