@mui/x-tree-view-pro 8.0.0-alpha.13 → 8.0.0-alpha.14

package/modern/RichTreeViewPro/RichTreeViewPro.plugins.d.ts

@@ -1,7 +1,7 @@
-import { UseTreeViewItemsParameters, UseTreeViewExpansionParameters, UseTreeViewSelectionParameters, UseTreeViewFocusParameters, UseTreeViewIconsParameters, ConvertPluginsIntoSignatures, MergeSignaturesProperty, TreeViewCorePluginParameters, UseTreeViewLabelParameters } from '@mui/x-tree-view/internals';
+import { UseTreeViewItemsParameters, UseTreeViewExpansionParameters, UseTreeViewSelectionParameters, UseTreeViewFocusParameters, UseTreeViewIconsParameters, ConvertPluginsIntoSignatures, MergeSignaturesProperty, TreeViewCorePluginParameters, UseTreeViewLabelParameters, UseTreeViewLazyLoadingParameters } from '@mui/x-tree-view/internals';
 import { UseTreeViewItemsReorderingParameters } from "../internals/plugins/useTreeViewItemsReordering/index.js";
-export declare const RICH_TREE_VIEW_PRO_PLUGINS: readonly [import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewItemsSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewExpansionSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewSelectionSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewFocusSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewKeyboardNavigationSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewIconsSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewLabelSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("../internals").UseTreeViewItemsReorderingSignature>];
+export declare const RICH_TREE_VIEW_PRO_PLUGINS: readonly [import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewItemsSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewExpansionSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewSelectionSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewFocusSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewKeyboardNavigationSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewIconsSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewLabelSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("@mui/x-tree-view/internals").UseTreeViewLazyLoadingSignature>, import("@mui/x-tree-view/internals").TreeViewPlugin<import("../internals").UseTreeViewItemsReorderingSignature>];
 export type RichTreeViewProPluginSignatures = ConvertPluginsIntoSignatures<typeof RICH_TREE_VIEW_PRO_PLUGINS>;
 export type RichTreeViewProPluginSlots = MergeSignaturesProperty<RichTreeViewProPluginSignatures, 'slots'>;
 export type RichTreeViewProPluginSlotProps = MergeSignaturesProperty<RichTreeViewProPluginSignatures, 'slotProps'>;
-export interface RichTreeViewProPluginParameters<R extends {}, Multiple extends boolean | undefined> extends TreeViewCorePluginParameters, UseTreeViewItemsParameters<R>, UseTreeViewExpansionParameters, UseTreeViewFocusParameters, UseTreeViewSelectionParameters<Multiple>, UseTreeViewIconsParameters, UseTreeViewLabelParameters<R>, UseTreeViewItemsReorderingParameters {}
+export interface RichTreeViewProPluginParameters<R extends {}, Multiple extends boolean | undefined> extends TreeViewCorePluginParameters, UseTreeViewItemsParameters<R>, UseTreeViewExpansionParameters, UseTreeViewFocusParameters, UseTreeViewSelectionParameters<Multiple>, UseTreeViewIconsParameters, UseTreeViewLabelParameters<R>, UseTreeViewLazyLoadingParameters<R>, UseTreeViewItemsReorderingParameters {}

package/modern/RichTreeViewPro/RichTreeViewPro.plugins.js

@@ -1,5 +1,6 @@
 import { useTreeViewItems, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewIcons, useTreeViewLabel } from '@mui/x-tree-view/internals';
 import { useTreeViewItemsReordering } from "../internals/plugins/useTreeViewItemsReordering/index.js";
-export const RICH_TREE_VIEW_PRO_PLUGINS = [useTreeViewItems, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewIcons, useTreeViewLabel, useTreeViewItemsReordering];
+import { useTreeViewLazyLoading } from "../internals/plugins/useTreeViewLazyLoading/index.js";
+export const RICH_TREE_VIEW_PRO_PLUGINS = [useTreeViewItems, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewIcons, useTreeViewLabel, useTreeViewLazyLoading, useTreeViewItemsReordering];
 
 // We can't infer this type from the plugin, otherwise we would lose the generics.

package/modern/index.js

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

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

@@ -89,6 +89,8 @@ export declare const selectorItemsReorderingDraggedItemProperties: ((state: any,
           [itemId: string]: number;
         };
       };
+      loading: boolean;
+      error: Error | null;
     }) => {
       [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
     };
@@ -108,6 +110,8 @@ export declare const selectorItemsReorderingDraggedItemProperties: ((state: any,
           [itemId: string]: number;
         };
       };
+      loading: boolean;
+      error: Error | null;
     }) => {
       [itemId: string]: import("@mui/x-tree-view/internals").TreeViewItemMeta;
     }) & {

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

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

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

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

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

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

package/modern/internals/plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.js

@@ -0,0 +1,288 @@
+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';
+import { NestedDataManager } from "./utils.js";
+const INITIAL_STATE = {
+  loading: {},
+  errors: {}
+};
+const noopCache = {
+  clear: () => {},
+  get: () => undefined,
+  set: () => {}
+};
+function getCache(cacheProp) {
+  if (cacheProp === null) {
+    return noopCache;
+  }
+  return cacheProp ?? new DataSourceCacheDefault({});
+}
+export const useTreeViewLazyLoading = ({
+  instance,
+  params,
+  store
+}) => {
+  const isLazyLoadingEnabled = params.dataSource?.getChildrenCount !== undefined;
+  const firstRenderRef = React.useRef(true);
+  const nestedDataManager = useLazyRef(() => new NestedDataManager(instance)).current;
+  const cacheRef = useLazyRef(() => getCache(params.dataSourceCache));
+  const setDataSourceLoading = useEventCallback((itemId, isLoading) => {
+    if (!isLazyLoadingEnabled) {
+      return;
+    }
+    store.update(prevState => {
+      if (!prevState.lazyLoading.dataSource.loading[itemId] && !isLoading) {
+        return prevState;
+      }
+      const loading = _extends({}, prevState.lazyLoading.dataSource.loading);
+      if (isLoading === false) {
+        delete loading[itemId];
+      } else {
+        loading[itemId] = isLoading;
+      }
+      return _extends({}, prevState, {
+        lazyLoading: _extends({}, prevState.lazyLoading, {
+          dataSource: _extends({}, prevState.lazyLoading.dataSource, {
+            loading
+          })
+        })
+      });
+    });
+  });
+  const setDataSourceError = (itemId, error) => {
+    if (!isLazyLoadingEnabled) {
+      return;
+    }
+    store.update(prevState => {
+      const errors = _extends({}, prevState.lazyLoading.dataSource.errors);
+      if (error === null && errors[itemId] !== undefined) {
+        delete errors[itemId];
+      } else {
+        errors[itemId] = error;
+      }
+      errors[itemId] = error;
+      return _extends({}, prevState, {
+        lazyLoading: _extends({}, prevState.lazyLoading, {
+          dataSource: _extends({}, prevState.lazyLoading.dataSource, {
+            errors
+          })
+        })
+      });
+    });
+  };
+  const resetDataSourceState = useEventCallback(() => {
+    if (!isLazyLoadingEnabled) {
+      return;
+    }
+    store.update(prevState => _extends({}, prevState, {
+      lazyLoading: _extends({}, prevState.lazyLoading, {
+        dataSource: INITIAL_STATE
+      })
+    }));
+  });
+  const fetchItems = useEventCallback(async parentIds => {
+    if (!isLazyLoadingEnabled) {
+      return;
+    }
+    const getChildrenCount = params.dataSource?.getChildrenCount || (() => 0);
+    const getTreeItems = params.dataSource?.getTreeItems;
+    if (!getTreeItems) {
+      return;
+    }
+    if (parentIds) {
+      await nestedDataManager.queue(parentIds);
+      return;
+    }
+    nestedDataManager.clear();
+
+    // reset the state if we are refetching the first visible items
+    if (selectorDataSourceState(store.value) !== INITIAL_STATE) {
+      resetDataSourceState();
+    }
+    // handle caching here
+    const cachedData = cacheRef.current.get('root');
+    if (cachedData !== undefined) {
+      return;
+    }
+
+    // handle loading here
+    instance.setTreeViewLoading(true);
+    try {
+      const getTreeItemsResponse = await getTreeItems();
+
+      // set caching
+      cacheRef.current.set('root', getTreeItemsResponse);
+
+      // update the items in the state
+      instance.addItems({
+        items: getTreeItemsResponse,
+        depth: 0,
+        getChildrenCount
+      });
+    } catch (error) {
+      // set the items to empty
+      instance.addItems({
+        items: [],
+        depth: 0,
+        getChildrenCount
+      });
+      // set error state
+      instance.setTreeViewError(error);
+    } finally {
+      // set loading state
+      instance.setTreeViewLoading(false);
+    }
+  });
+  const fetchItemChildren = useEventCallback(async id => {
+    if (!isLazyLoadingEnabled) {
+      return;
+    }
+    const getChildrenCount = params.dataSource?.getChildrenCount || (() => 0);
+    const getTreeItems = params.dataSource?.getTreeItems;
+    if (!getTreeItems) {
+      nestedDataManager.clearPendingRequest(id);
+      return;
+    }
+    const parent = selectorItemMeta(store.value, id);
+    if (!parent) {
+      nestedDataManager.clearPendingRequest(id);
+      return;
+    }
+    const depth = parent.depth ? parent.depth + 1 : 1;
+
+    // handle loading here
+    instance.setDataSourceLoading(id, true);
+
+    // handle caching here
+    const cachedData = cacheRef.current.get(id);
+    if (cachedData !== undefined && cachedData !== -1) {
+      nestedDataManager.setRequestSettled(id);
+      instance.addItems({
+        items: cachedData,
+        depth,
+        parentId: id,
+        getChildrenCount
+      });
+      instance.setDataSourceLoading(id, false);
+      return;
+    }
+    if (cachedData === -1) {
+      instance.removeChildren(id);
+    }
+    const existingError = selectorGetTreeItemError(store.value, id) ?? null;
+    if (existingError) {
+      instance.setDataSourceError(id, null);
+    }
+    try {
+      const getTreeItemsResponse = await getTreeItems(id);
+      nestedDataManager.setRequestSettled(id);
+
+      // set caching
+      cacheRef.current.set(id, getTreeItemsResponse);
+      // update the items in the state
+      instance.addItems({
+        items: getTreeItemsResponse,
+        depth,
+        parentId: id,
+        getChildrenCount
+      });
+    } catch (error) {
+      const childrenFetchError = error;
+      // handle errors here
+      instance.setDataSourceError(id, childrenFetchError);
+      instance.removeChildren(id);
+    } finally {
+      // unset loading
+      instance.setDataSourceLoading(id, false);
+      nestedDataManager.setRequestSettled(id);
+    }
+  });
+  useInstanceEventHandler(instance, 'beforeItemToggleExpansion', async eventParameters => {
+    if (!isLazyLoadingEnabled || !eventParameters.shouldBeExpanded) {
+      return;
+    }
+    eventParameters.isExpansionPrevented = true;
+    await instance.fetchItems([eventParameters.itemId]);
+    const fetchErrors = Boolean(selectorGetTreeItemError(store.value, eventParameters.itemId));
+    if (!fetchErrors) {
+      instance.applyItemExpansion({
+        itemId: eventParameters.itemId,
+        shouldBeExpanded: true,
+        event: eventParameters.event
+      });
+      if (selectorIsItemSelected(store.value, eventParameters.itemId)) {
+        // make sure selection propagation works correctly
+        instance.setItemSelection({
+          event: eventParameters.event,
+          itemId: eventParameters.itemId,
+          keepExistingSelection: true,
+          shouldBeSelected: true
+        });
+      }
+    }
+  });
+  React.useEffect(() => {
+    if (isLazyLoadingEnabled && firstRenderRef.current) {
+      store.update(prevState => _extends({}, prevState, {
+        lazyLoading: _extends({}, prevState.lazyLoading, {
+          enabled: true
+        })
+      }));
+      if (params.items.length) {
+        const getChildrenCount = params.dataSource?.getChildrenCount || (() => 0);
+        instance.addItems({
+          items: params.items,
+          depth: 0,
+          getChildrenCount
+        });
+      } else {
+        instance.fetchItems();
+      }
+      firstRenderRef.current = false;
+    }
+  }, [instance, params.items, params.dataSource, isLazyLoadingEnabled, store]);
+  if (isLazyLoadingEnabled) {
+    instance.preventItemUpdates();
+  }
+  return {
+    instance: {
+      fetchItemChildren,
+      fetchItems,
+      setDataSourceLoading,
+      setDataSourceError
+    },
+    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,
+    dataSource: INITIAL_STATE
+  }
+});
+useTreeViewLazyLoading.params = {
+  dataSource: true,
+  dataSourceCache: true
+};

package/modern/internals/plugins/useTreeViewLazyLoading/utils.d.ts

@@ -0,0 +1,32 @@
+import { TreeViewInstance, UseTreeViewLazyLoadingSignature } from '@mui/x-tree-view/internals';
+import { TreeViewItemId } from '@mui/x-tree-view/models';
+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`
+ * Uses `ParentId` to uniquely identify a request
+ */
+export declare class NestedDataManager {
+  private pendingRequests;
+  private queuedRequests;
+  private settledRequests;
+  private instance;
+  private maxConcurrentRequests;
+  constructor(instance: TreeViewInstance<[UseTreeViewLazyLoadingSignature]>, maxConcurrentRequests?: number);
+  private processQueue;
+  queue: (ids: TreeViewItemId[]) => Promise<void>;
+  setRequestSettled: (id: TreeViewItemId) => Promise<void>;
+  clear: () => void;
+  clearPendingRequest: (id: TreeViewItemId) => Promise<void>;
+  getRequestStatus: (id: TreeViewItemId) => RequestStatus;
+  getActiveRequestsCount: () => number;
+}

package/modern/internals/plugins/useTreeViewLazyLoading/utils.js

@@ -0,0 +1,85 @@
+const MAX_CONCURRENT_REQUESTS = Infinity;
+export let RequestStatus = /*#__PURE__*/function (RequestStatus) {
+  RequestStatus[RequestStatus["QUEUED"] = 0] = "QUEUED";
+  RequestStatus[RequestStatus["PENDING"] = 1] = "PENDING";
+  RequestStatus[RequestStatus["SETTLED"] = 2] = "SETTLED";
+  RequestStatus[RequestStatus["UNKNOWN"] = 3] = "UNKNOWN";
+  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`
+ * Uses `ParentId` to uniquely identify a request
+ */
+export class NestedDataManager {
+  constructor(instance, maxConcurrentRequests = MAX_CONCURRENT_REQUESTS) {
+    this.pendingRequests = new Set();
+    this.queuedRequests = new Set();
+    this.settledRequests = new Set();
+    this.instance = void 0;
+    this.maxConcurrentRequests = void 0;
+    this.processQueue = async () => {
+      if (this.queuedRequests.size === 0 || this.pendingRequests.size >= this.maxConcurrentRequests) {
+        return;
+      }
+      const loopLength = Math.min(this.maxConcurrentRequests - this.pendingRequests.size, this.queuedRequests.size);
+      if (loopLength === 0) {
+        return;
+      }
+      const fetchQueue = Array.from(this.queuedRequests);
+      const fetchPromises = [];
+      for (let i = 0; i < loopLength; i += 1) {
+        const id = fetchQueue[i];
+        this.queuedRequests.delete(id);
+        this.pendingRequests.add(id);
+        fetchPromises.push(this.instance.fetchItemChildren(id));
+      }
+      await Promise.all(fetchPromises);
+    };
+    this.queue = async ids => {
+      const loadingIds = {};
+      ids.forEach(id => {
+        this.queuedRequests.add(id);
+        loadingIds[id] = true;
+      });
+      await this.processQueue();
+    };
+    this.setRequestSettled = async id => {
+      this.pendingRequests.delete(id);
+      this.settledRequests.add(id);
+      await this.processQueue();
+    };
+    this.clear = () => {
+      this.queuedRequests.clear();
+      Array.from(this.pendingRequests).forEach(id => this.clearPendingRequest(id));
+    };
+    this.clearPendingRequest = async id => {
+      this.pendingRequests.delete(id);
+      await this.processQueue();
+    };
+    this.getRequestStatus = id => {
+      if (this.pendingRequests.has(id)) {
+        return RequestStatus.PENDING;
+      }
+      if (this.queuedRequests.has(id)) {
+        return RequestStatus.QUEUED;
+      }
+      if (this.settledRequests.has(id)) {
+        return RequestStatus.SETTLED;
+      }
+      return RequestStatus.UNKNOWN;
+    };
+    this.getActiveRequestsCount = () => this.pendingRequests.size + this.queuedRequests.size;
+    this.instance = instance;
+    this.maxConcurrentRequests = maxConcurrentRequests;
+  }
+}

package/modern/internals/utils/releaseInfo.js

@@ -1,6 +1,6 @@
 import ponyfillGlobal from '@mui/utils/ponyfillGlobal';
 export const getReleaseInfo = () => {
-  const releaseInfo = "MTc0MDY5NzIwMDAwMA==";
+  const releaseInfo = "MTc0MTMwMjAwMDAwMA==";
   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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-tree-view-pro",
-  "version": "8.0.0-alpha.13",
+  "version": "8.0.0-alpha.14",
   "description": "The Pro plan edition of the Tree View components (MUI X).",
   "author": "MUI Team",
   "main": "./index.js",
@@ -42,8 +42,8 @@
     "reselect": "^5.1.1",
     "use-sync-external-store": "^1.4.0",
     "@mui/x-internals": "8.0.0-alpha.13",
-    "@mui/x-tree-view": "8.0.0-alpha.13",
-    "@mui/x-license": "8.0.0-alpha.13"
+    "@mui/x-license": "8.0.0-alpha.14",
+    "@mui/x-tree-view": "8.0.0-alpha.14"
   },
   "peerDependencies": {
     "@emotion/react": "^11.9.0",