@mui/x-tree-view 8.0.0-alpha.9 → 8.0.0-beta.1

package/modern/hooks/useTreeItemUtils/useTreeItemUtils.js

@@ -4,10 +4,11 @@ import { useTreeViewContext } from "../../internals/TreeViewProvider/index.js";
 import { useTreeViewLabel } from "../../internals/plugins/useTreeViewLabel/index.js";
 import { hasPlugin } from "../../internals/utils/plugins.js";
 import { useSelector } from "../../internals/hooks/useSelector.js";
-import { selectorIsItemExpanded } from "../../internals/plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
+import { selectorIsItemExpandable, selectorIsItemExpanded } from "../../internals/plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
 import { selectorIsItemFocused } from "../../internals/plugins/useTreeViewFocus/useTreeViewFocus.selectors.js";
 import { selectorIsItemDisabled } from "../../internals/plugins/useTreeViewItems/useTreeViewItems.selectors.js";
-import { selectorIsItemSelected } from "../../internals/plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";
+import { selectorIsItemSelected, selectorIsMultiSelectEnabled } from "../../internals/plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";
+import { selectorGetTreeItemError, selectorIsItemLoading, selectorIsLazyLoadingEnabled } from "../../internals/plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.selectors.js";
 import { selectorIsItemBeingEdited, selectorIsItemEditable } from "../../internals/plugins/useTreeViewLabel/useTreeViewLabel.selectors.js";
 
 /**
@@ -18,9 +19,9 @@ import { selectorIsItemBeingEdited, selectorIsItemEditable } from "../../interna
  * Plugins that `useTreeItemUtils` can use if they are present, but are not required.
  */
 
-export const isItemExpandable = reactChildren => {
+export const itemHasChildren = reactChildren => {
   if (Array.isArray(reactChildren)) {
-    return reactChildren.length > 0 && reactChildren.some(isItemExpandable);
+    return reactChildren.length > 0 && reactChildren.some(itemHasChildren);
   }
   return Boolean(reactChildren);
 };
@@ -30,30 +31,31 @@ export const useTreeItemUtils = ({
 }) => {
   const {
     instance,
-    label,
     store,
-    selection: {
-      multiSelect
-    },
     publicAPI
   } = useTreeViewContext();
+  const isItemExpandable = useSelector(store, selectorIsItemExpandable, itemId);
+  const isLazyLoadingEnabled = useSelector(store, selectorIsLazyLoadingEnabled);
+  const isMultiSelectEnabled = useSelector(store, selectorIsMultiSelectEnabled);
+  const loading = useSelector(store, state => isLazyLoadingEnabled ? selectorIsItemLoading(state, itemId) : false);
+  const error = useSelector(store, state => isLazyLoadingEnabled ? Boolean(selectorGetTreeItemError(state, itemId)) : false);
+  const isExpandable = itemHasChildren(children) || isItemExpandable;
   const isExpanded = useSelector(store, selectorIsItemExpanded, itemId);
   const isFocused = useSelector(store, selectorIsItemFocused, itemId);
   const isSelected = useSelector(store, selectorIsItemSelected, itemId);
   const isDisabled = useSelector(store, selectorIsItemDisabled, itemId);
-  const isEditing = useSelector(store, state => label == null ? false : selectorIsItemBeingEdited(state, itemId));
-  const isEditable = useSelector(store, state => label == null ? false : selectorIsItemEditable(state, {
-    itemId,
-    isItemEditable: label.isItemEditable
-  }));
+  const isEditing = useSelector(store, selectorIsItemBeingEdited, itemId);
+  const isEditable = useSelector(store, selectorIsItemEditable, itemId);
   const status = {
-    expandable: isItemExpandable(children),
+    expandable: isExpandable,
     expanded: isExpanded,
     focused: isFocused,
     selected: isSelected,
     disabled: isDisabled,
     editing: isEditing,
-    editable: isEditable
+    editable: isEditable,
+    loading,
+    error
   };
   const handleExpansion = event => {
     if (status.disabled) {
@@ -62,11 +64,15 @@ export const useTreeItemUtils = ({
     if (!status.focused) {
       instance.focusItem(event, itemId);
     }
-    const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
+    const multiple = isMultiSelectEnabled && (event.shiftKey || event.ctrlKey || event.metaKey);
 
     // If already expanded and trying to toggle selection don't close
     if (status.expandable && !(multiple && selectorIsItemExpanded(store.value, itemId))) {
-      instance.toggleItemExpansion(event, itemId);
+      // make sure the children selection is propagated again
+      instance.setItemExpansion({
+        event,
+        itemId
+      });
     }
   };
   const handleSelection = event => {
@@ -76,19 +82,19 @@ export const useTreeItemUtils = ({
     if (!status.focused) {
       instance.focusItem(event, itemId);
     }
-    const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
+    const multiple = isMultiSelectEnabled && (event.shiftKey || event.ctrlKey || event.metaKey);
     if (multiple) {
       if (event.shiftKey) {
         instance.expandSelectionRange(event, itemId);
       } else {
-        instance.selectItem({
+        instance.setItemSelection({
           event,
           itemId,
           keepExistingSelection: true
         });
       }
     } else {
-      instance.selectItem({
+      instance.setItemSelection({
         event,
         itemId,
         shouldBeSelected: true
@@ -97,13 +103,13 @@ export const useTreeItemUtils = ({
   };
   const handleCheckboxSelection = event => {
     const hasShift = event.nativeEvent.shiftKey;
-    if (multiSelect && hasShift) {
+    if (isMultiSelectEnabled && hasShift) {
       instance.expandSelectionRange(event, itemId);
     } else {
-      instance.selectItem({
+      instance.setItemSelection({
         event,
         itemId,
-        keepExistingSelection: multiSelect,
+        keepExistingSelection: isMultiSelectEnabled,
         shouldBeSelected: event.target.checked
       });
     }

package/modern/hooks/useTreeViewApiRef.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { TreeViewAnyPluginSignature, TreeViewPublicAPI } from "../internals/models/index.js";
+import { RichTreeViewPluginSignatures } from "../RichTreeView/RichTreeView.plugins.js";
+/**
+ * Hook that instantiates a [[TreeViewApiRef]].
+ */
+export declare const useTreeViewApiRef: <TSignatures extends readonly TreeViewAnyPluginSignature[] = RichTreeViewPluginSignatures>() => React.RefObject<TreeViewPublicAPI<TSignatures> | undefined>;

package/modern/icons/icons.d.ts

@@ -0,0 +1,6 @@
+export declare const TreeViewExpandIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+  muiName: string;
+};
+export declare const TreeViewCollapseIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+  muiName: string;
+};

package/modern/icons/index.d.ts

@@ -0,0 +1 @@
+export * from "./icons.js";

package/modern/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./SimpleTreeView/index.js";
+export * from "./RichTreeView/index.js";
+export * from "./TreeItem/index.js";
+export * from "./useTreeItem/index.js";
+export * from "./TreeItemIcon/index.js";
+export * from "./TreeItemProvider/index.js";
+export * from "./TreeItemDragAndDropOverlay/index.js";
+export * from "./TreeItemLabelInput/index.js";
+export { unstable_resetCleanupTracking } from "./internals/hooks/useInstanceEventHandler.js";
+export * from "./models/index.js";
+export * from "./icons/index.js";
+export * from "./hooks/index.js";

package/modern/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-tree-view v8.0.0-alpha.9
+ * @mui/x-tree-view v8.0.0-beta.1
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/modern/internals/TreeViewItemDepthContext/TreeViewItemDepthContext.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import { TreeViewItemId } from "../../models/index.js";
+import { TreeViewState } from "../models/index.js";
+import type { UseTreeViewItemsSignature } from '../plugins/useTreeViewItems';
+export declare const TreeViewItemDepthContext: React.Context<number | ((state: TreeViewState<[UseTreeViewItemsSignature]>, itemId: TreeViewItemId) => number)>;

package/modern/internals/TreeViewItemDepthContext/index.d.ts

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

package/modern/internals/TreeViewProvider/TreeViewChildrenItemProvider.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+export declare const TreeViewChildrenItemContext: React.Context<TreeViewChildrenItemContextValue | null>;
+interface TreeViewChildrenItemProviderProps {
+  itemId: string | null;
+  idAttribute: string | null;
+  children: React.ReactNode;
+}
+export declare function TreeViewChildrenItemProvider(props: TreeViewChildrenItemProviderProps): React.JSX.Element;
+export declare namespace TreeViewChildrenItemProvider {
+  var propTypes: any;
+}
+interface TreeViewChildrenItemContextValue {
+  registerChild: (idAttribute: string, itemId: string) => void;
+  unregisterChild: (idAttribute: string) => void;
+  parentId: string | null;
+}
+export {};

package/modern/internals/TreeViewProvider/TreeViewContext.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { TreeViewContextValue } from "./TreeViewProvider.types.js";
+/**
+ * @ignore - internal component.
+ */
+export declare const TreeViewContext: React.Context<TreeViewContextValue<any> | null>;

package/modern/internals/TreeViewProvider/TreeViewProvider.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { TreeViewProviderProps } from "./TreeViewProvider.types.js";
+import { TreeViewAnyPluginSignature } from "../models/index.js";
+/**
+ * Sets up the contexts for the underlying TreeItem components.
+ *
+ * @ignore - do not document.
+ */
+export declare function TreeViewProvider<TSignatures extends readonly TreeViewAnyPluginSignature[]>(props: TreeViewProviderProps<TSignatures>): React.JSX.Element;

package/modern/internals/TreeViewProvider/TreeViewProvider.types.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { MergeSignaturesProperty, TreeItemWrapper, TreeRootWrapper, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginResponse, TreeViewPublicAPI } from "../models/index.js";
+import { TreeViewStore } from "../utils/TreeViewStore.js";
+import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
+import type { TreeItemProps } from '../../TreeItem/TreeItem.types';
+export type TreeViewItemPluginsRunner = (props: TreeItemProps) => Required<TreeViewItemPluginResponse>;
+export type TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'contextValue'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'contextValue'>> & {
+  instance: TreeViewInstance<TSignatures, TOptionalSignatures>;
+  publicAPI: TreeViewPublicAPI<TSignatures, TOptionalSignatures>;
+  store: TreeViewStore<TSignatures>;
+  rootRef: React.RefObject<HTMLUListElement | null>;
+  wrapItem: TreeItemWrapper<TSignatures>;
+  wrapRoot: TreeRootWrapper;
+  runItemPlugins: TreeViewItemPluginsRunner;
+};
+export interface TreeViewProviderProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
+  value: TreeViewContextValue<TSignatures>;
+  children: React.ReactNode;
+}

package/modern/internals/TreeViewProvider/index.d.ts

@@ -0,0 +1,3 @@
+export { TreeViewProvider } from "./TreeViewProvider.js";
+export { useTreeViewContext } from "./useTreeViewContext.js";
+export type { TreeViewProviderProps, TreeViewContextValue, TreeViewItemPluginsRunner } from './TreeViewProvider.types';

package/modern/internals/TreeViewProvider/useTreeViewContext.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewAnyPluginSignature } from "../models/index.js";
+import { TreeViewContextValue } from "./TreeViewProvider.types.js";
+export declare const useTreeViewContext: <TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []>() => TreeViewContextValue<TSignatures, TOptionalSignatures>;

package/modern/internals/components/RichTreeViewItems.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { SlotComponentProps } from '@mui/utils/types';
+import { TreeItem, TreeItemProps } from "../../TreeItem/index.js";
+import { TreeViewItemId } from "../../models/index.js";
+export declare function RichTreeViewItems(props: RichTreeViewItemsProps): React.JSX.Element;
+interface RichTreeViewItemsOwnerState {
+  itemId: TreeViewItemId;
+  label: string;
+}
+export interface RichTreeViewItemsSlots {
+  /**
+   * Custom component to render a Tree Item.
+   * @default TreeItem.
+   */
+  item?: React.JSXElementConstructor<TreeItemProps>;
+}
+export interface RichTreeViewItemsSlotProps {
+  item?: SlotComponentProps<typeof TreeItem, {}, RichTreeViewItemsOwnerState>;
+}
+export interface RichTreeViewItemsProps {
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: RichTreeViewItemsSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: RichTreeViewItemsSlotProps;
+}
+export {};

package/modern/internals/corePlugins/corePlugins.d.ts

@@ -0,0 +1,9 @@
+import { UseTreeViewIdParameters } from "./useTreeViewId/index.js";
+import { ConvertPluginsIntoSignatures } from "../models/index.js";
+/**
+ * Internal plugins that create the tools used by the other plugins.
+ * These plugins are used by the Tree View components.
+ */
+export declare const TREE_VIEW_CORE_PLUGINS: readonly [import("..").TreeViewPlugin<import("./useTreeViewInstanceEvents").UseTreeViewInstanceEventsSignature>, import("..").TreeViewPlugin<import("./useTreeViewOptionalPlugins").UseTreeViewOptionalPluginsSignature>, import("..").TreeViewPlugin<import("./useTreeViewId").UseTreeViewIdSignature>];
+export type TreeViewCorePluginSignatures = ConvertPluginsIntoSignatures<typeof TREE_VIEW_CORE_PLUGINS>;
+export interface TreeViewCorePluginParameters extends UseTreeViewIdParameters {}

package/modern/internals/corePlugins/index.d.ts

@@ -0,0 +1,2 @@
+export { TREE_VIEW_CORE_PLUGINS } from "./corePlugins.js";
+export type { TreeViewCorePluginSignatures, TreeViewCorePluginParameters } from './corePlugins';

package/modern/internals/corePlugins/useTreeViewId/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewId } from "./useTreeViewId.js";
+export type { UseTreeViewIdSignature, UseTreeViewIdParameters, UseTreeViewIdDefaultizedParameters } from './useTreeViewId.types';

package/modern/internals/corePlugins/useTreeViewId/useTreeViewId.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewPlugin } from "../../models/index.js";
+import { UseTreeViewIdSignature } from "./useTreeViewId.types.js";
+export declare const useTreeViewId: TreeViewPlugin<UseTreeViewIdSignature>;

package/modern/internals/corePlugins/useTreeViewId/useTreeViewId.selectors.d.ts

@@ -0,0 +1,36 @@
+import { TreeViewRootSelector } from "../../utils/selectors.js";
+import { UseTreeViewIdSignature } from "./useTreeViewId.types.js";
+/**
+ * Get the id attribute of the tree view.
+ * @param {TreeViewState<[UseTreeViewIdSignature]>} state The state of the tree view.
+ * @returns {string} The id attribute of the tree view.
+ */
+export declare const selectorTreeViewId: ((state: import("./useTreeViewId.types").UseTreeViewIdState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => string | undefined) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    treeId: string | undefined;
+    providedTreeId: string | undefined;
+  }) => string | undefined;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    treeId: string | undefined;
+    providedTreeId: string | undefined;
+  }) => string | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string | undefined;
+  dependencies: [TreeViewRootSelector<UseTreeViewIdSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

package/modern/internals/corePlugins/useTreeViewId/useTreeViewId.types.d.ts

@@ -0,0 +1,20 @@
+import { TreeViewPluginSignature } from "../../models/index.js";
+export interface UseTreeViewIdParameters {
+  /**
+   * This prop is used to help implement the accessibility logic.
+   * If you don't provide this prop. It falls back to a randomly generated id.
+   */
+  id?: string;
+}
+export type UseTreeViewIdDefaultizedParameters = UseTreeViewIdParameters;
+export interface UseTreeViewIdState {
+  id: {
+    treeId: string | undefined;
+    providedTreeId: string | undefined;
+  };
+}
+export type UseTreeViewIdSignature = TreeViewPluginSignature<{
+  params: UseTreeViewIdParameters;
+  defaultizedParams: UseTreeViewIdDefaultizedParameters;
+  state: UseTreeViewIdState;
+}>;

package/modern/internals/corePlugins/useTreeViewId/useTreeViewId.utils.d.ts

@@ -0,0 +1,21 @@
+import { TreeViewItemId } from "../../../models/index.js";
+export declare const createTreeViewDefaultId: () => string;
+/**
+ * Generate the id attribute (i.e.: the `id` attribute passed to the DOM element) of a Tree Item.
+ * If the user explicitly defined an id attribute, it will be returned.
+ * Otherwise, the method creates a unique id for the item based on the Tree View id attribute and the item `itemId`
+ * @param {object} params The parameters to determine the id attribute of the item.
+ * @param {TreeViewItemId} params.itemId The id of the item to get the id attribute of.
+ * @param {string | undefined} params.idAttribute The id attribute of the item if explicitly defined by the user.
+ * @param {string} params.treeId The id attribute of the Tree View.
+ * @returns {string} The id attribute of the item.
+ */
+export declare const generateTreeItemIdAttribute: ({
+  id,
+  treeId,
+  itemId
+}: {
+  id: TreeViewItemId | undefined;
+  treeId: string | undefined;
+  itemId: string;
+}) => string;

package/modern/internals/corePlugins/useTreeViewInstanceEvents/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewInstanceEvents } from "./useTreeViewInstanceEvents.js";
+export type { UseTreeViewInstanceEventsSignature } from './useTreeViewInstanceEvents.types';

package/modern/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.d.ts

@@ -0,0 +1,3 @@
+import type { TreeViewPlugin } from '../../models';
+import { UseTreeViewInstanceEventsSignature } from "./useTreeViewInstanceEvents.types.js";
+export declare const useTreeViewInstanceEvents: TreeViewPlugin<UseTreeViewInstanceEventsSignature>;

package/modern/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types.d.ts

@@ -0,0 +1,22 @@
+import { TreeViewPluginSignature } from "../../models/index.js";
+import { TreeViewEventListener } from "../../models/events.js";
+export interface UseTreeViewInstanceEventsInstance {
+  /**
+   * Should never be used directly.
+   * Please use `useInstanceEventHandler` instead.
+   * @param {string} eventName Name of the event to subscribe to.
+   * @param {TreeViewEventListener<any>} handler Event handler to call when the event is published.
+   * @returns {() => void} Cleanup function.
+   */
+  $$subscribeEvent: (eventName: string, handler: TreeViewEventListener<any>) => () => void;
+  /**
+   * Should never be used directly.
+   * Please use `publishTreeViewEvent` instead.
+   * @param {string} eventName Name of the event to publish.
+   * @param {any} params The params to publish with the event.
+   */
+  $$publishEvent: (eventName: string, params: any) => void;
+}
+export type UseTreeViewInstanceEventsSignature = TreeViewPluginSignature<{
+  instance: UseTreeViewInstanceEventsInstance;
+}>;

package/modern/internals/corePlugins/useTreeViewOptionalPlugins/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewOptionalPlugins } from "./useTreeViewOptionalPlugins.js";
+export type { UseTreeViewOptionalPluginsSignature } from './useTreeViewOptionalPlugins.types';

package/modern/internals/corePlugins/useTreeViewOptionalPlugins/useTreeViewOptionalPlugins.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewPlugin } from "../../models/index.js";
+import { UseTreeViewOptionalPluginsSignature } from "./useTreeViewOptionalPlugins.types.js";
+export declare const useTreeViewOptionalPlugins: TreeViewPlugin<UseTreeViewOptionalPluginsSignature>;

package/modern/internals/corePlugins/useTreeViewOptionalPlugins/useTreeViewOptionalPlugins.types.d.ts

@@ -0,0 +1,8 @@
+import { TreeViewPlugin, TreeViewAnyPluginSignature, TreeViewPluginSignature } from "../../models/index.js";
+interface UseTreeViewOptionalPluginsInstance {
+  getAvailablePlugins: () => Set<TreeViewPlugin<TreeViewAnyPluginSignature>>;
+}
+export type UseTreeViewOptionalPluginsSignature = TreeViewPluginSignature<{
+  instance: UseTreeViewOptionalPluginsInstance;
+}>;
+export {};

package/modern/internals/hooks/useInstanceEventHandler.d.ts

@@ -0,0 +1,15 @@
+import { CleanupTracking } from "../utils/cleanupTracking/CleanupTracking.js";
+import { TreeViewAnyPluginSignature, TreeViewUsedEvents } from "../models/index.js";
+import { TreeViewEventListener } from "../models/events.js";
+import { UseTreeViewInstanceEventsInstance } from "../corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types.js";
+interface RegistryContainer {
+  registry: CleanupTracking | null;
+}
+export declare function createUseInstanceEventHandler(registryContainer: RegistryContainer): <Instance extends UseTreeViewInstanceEventsInstance & {
+  $$signature: TreeViewAnyPluginSignature;
+}, E extends keyof TreeViewUsedEvents<Instance["$$signature"]>>(instance: Instance, eventName: E, handler: TreeViewEventListener<TreeViewUsedEvents<Instance["$$signature"]>[E]>) => void;
+export declare const unstable_resetCleanupTracking: () => void;
+export declare const useInstanceEventHandler: <Instance extends UseTreeViewInstanceEventsInstance & {
+  $$signature: TreeViewAnyPluginSignature;
+}, E extends keyof TreeViewUsedEvents<Instance["$$signature"]>>(instance: Instance, eventName: E, handler: TreeViewEventListener<TreeViewUsedEvents<Instance["$$signature"]>[E]>) => void;
+export {};

package/modern/internals/hooks/useLazyRef.d.ts

@@ -0,0 +1 @@
+export { default as useLazyRef } from '@mui/utils/useLazyRef';

package/modern/internals/hooks/useOnMount.d.ts

@@ -0,0 +1 @@
+export { default as useOnMount } from '@mui/utils/useOnMount';

package/modern/internals/hooks/useSelector.d.ts

@@ -0,0 +1,4 @@
+import { TreeViewAnyPluginSignature, TreeViewState } from "../models/index.js";
+import { TreeViewStore } from "../utils/TreeViewStore.js";
+import { TreeViewSelector } from "../utils/selectors.js";
+export declare const useSelector: <TSignatures extends readonly TreeViewAnyPluginSignature[], TArgs, TValue>(store: TreeViewStore<TSignatures>, selector: TreeViewSelector<TreeViewState<TSignatures>, TArgs, TValue>, args?: TArgs, equals?: (a: TValue, b: TValue) => boolean) => TValue;

package/modern/internals/hooks/useSelector.js

@@ -1,4 +1,7 @@
-import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector';
+// use-sync-external-store has no exports field defined
+// See https://github.com/facebook/react/issues/30698
+// eslint-disable-next-line import/extensions
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector.js';
 const defaultCompare = Object.is;
 export const useSelector = (store, selector, args = undefined, equals = defaultCompare) => {
   const selectorWithArgs = state => selector(state, args);

package/modern/internals/hooks/useTimeout.d.ts

@@ -0,0 +1 @@
+export { default as useTimeout } from '@mui/utils/useTimeout';

package/modern/internals/index.d.ts

@@ -0,0 +1,33 @@
+export { useTreeView } from "./useTreeView/index.js";
+export { TreeViewProvider, useTreeViewContext } from "./TreeViewProvider/index.js";
+export { RichTreeViewItems } from "./components/RichTreeViewItems.js";
+export type { RichTreeViewItemsSlots, RichTreeViewItemsSlotProps } from './components/RichTreeViewItems';
+export { unstable_resetCleanupTracking, useInstanceEventHandler } from "./hooks/useInstanceEventHandler.js";
+export { useSelector } from "./hooks/useSelector.js";
+export type { TreeViewPlugin, TreeViewPluginSignature, ConvertPluginsIntoSignatures, MergeSignaturesProperty, TreeViewPublicAPI, TreeViewState, TreeViewExperimentalFeatures, TreeViewItemMeta, TreeViewInstance, TreeViewItemPlugin, TreeViewUsedStore } from './models';
+export type { TreeViewCorePluginParameters } from './corePlugins';
+export { useTreeViewExpansion } from "./plugins/useTreeViewExpansion/index.js";
+export type { UseTreeViewExpansionSignature, UseTreeViewExpansionParameters } from './plugins/useTreeViewExpansion';
+export { useTreeViewSelection } from "./plugins/useTreeViewSelection/index.js";
+export type { UseTreeViewSelectionSignature, UseTreeViewSelectionParameters } from './plugins/useTreeViewSelection';
+export { useTreeViewFocus } from "./plugins/useTreeViewFocus/index.js";
+export type { UseTreeViewFocusSignature, UseTreeViewFocusParameters } from './plugins/useTreeViewFocus';
+export { useTreeViewKeyboardNavigation } from "./plugins/useTreeViewKeyboardNavigation/index.js";
+export type { UseTreeViewKeyboardNavigationSignature } from './plugins/useTreeViewKeyboardNavigation';
+export { useTreeViewIcons } from "./plugins/useTreeViewIcons/index.js";
+export type { UseTreeViewIconsSignature, UseTreeViewIconsParameters } from './plugins/useTreeViewIcons';
+export { useTreeViewItems, buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from "./plugins/useTreeViewItems/index.js";
+export { selectorItemMetaLookup, selectorItemMeta, selectorItemIndex, selectorItemOrderedChildrenIds } from "./plugins/useTreeViewItems/useTreeViewItems.selectors.js";
+export type { UseTreeViewItemsSignature, UseTreeViewItemsParameters, UseTreeViewItemsState } from './plugins/useTreeViewItems';
+export { useTreeViewLabel } from "./plugins/useTreeViewLabel/index.js";
+export type { UseTreeViewLabelSignature, UseTreeViewLabelParameters } from './plugins/useTreeViewLabel';
+export { selectorIsItemExpanded } from "./plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
+export { selectorIsItemSelected } from "./plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";
+export { selectorDataSourceState, selectorGetTreeItemError } from "./plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.selectors.js";
+export type { UseTreeViewLazyLoadingSignature } from './plugins/useTreeViewLazyLoading';
+export type { UseTreeViewLazyLoadingParameters } from './plugins/useTreeViewLazyLoading';
+export { useTreeViewJSXItems } from "./plugins/useTreeViewJSXItems/index.js";
+export type { UseTreeViewJSXItemsSignature, UseTreeViewJSXItemsParameters } from './plugins/useTreeViewJSXItems';
+export { createSelector } from "./utils/selectors.js";
+export { isTargetInDescendants } from "./utils/tree.js";
+export { TreeViewStore } from "./utils/TreeViewStore.js";

package/modern/internals/index.js

@@ -1,7 +1,7 @@
 export { useTreeView } from "./useTreeView/index.js";
 export { TreeViewProvider, useTreeViewContext } from "./TreeViewProvider/index.js";
 export { RichTreeViewItems } from "./components/RichTreeViewItems.js";
-export { unstable_resetCleanupTracking } from "./hooks/useInstanceEventHandler.js";
+export { unstable_resetCleanupTracking, useInstanceEventHandler } from "./hooks/useInstanceEventHandler.js";
 export { useSelector } from "./hooks/useSelector.js";
 
 // Core plugins
@@ -15,6 +15,9 @@ export { useTreeViewIcons } from "./plugins/useTreeViewIcons/index.js";
 export { useTreeViewItems, buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from "./plugins/useTreeViewItems/index.js";
 export { selectorItemMetaLookup, selectorItemMeta, selectorItemIndex, selectorItemOrderedChildrenIds } from "./plugins/useTreeViewItems/useTreeViewItems.selectors.js";
 export { useTreeViewLabel } from "./plugins/useTreeViewLabel/index.js";
+export { selectorIsItemExpanded } from "./plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
+export { selectorIsItemSelected } from "./plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";
+export { selectorDataSourceState, selectorGetTreeItemError } from "./plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.selectors.js";
 export { useTreeViewJSXItems } from "./plugins/useTreeViewJSXItems/index.js";
 export { createSelector } from "./utils/selectors.js";
 export { isTargetInDescendants } from "./utils/tree.js";

package/modern/internals/models/events.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface TreeViewEventLookupElement {
+  params: object;
+}
+export type TreeViewEventListener<E extends TreeViewEventLookupElement> = (params: E['params'], event: MuiEvent<{}>) => void;
+export type MuiBaseEvent = React.SyntheticEvent<HTMLElement> | DocumentEventMap[keyof DocumentEventMap] | {};
+export type MuiEvent<E extends MuiBaseEvent = MuiBaseEvent> = E & {
+  defaultMuiPrevented?: boolean;
+};

package/modern/internals/models/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { TreeViewAnyPluginSignature, TreeViewPlugin } from './plugin';
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export type OptionalIfEmpty<A extends string, B> = keyof B extends never ? Partial<Record<A, B>> : IsAny<B> extends true ? Partial<Record<A, B>> : Record<A, B>;
+export type MergeSignaturesProperty<TSignatures extends readonly any[], TProperty extends keyof TreeViewAnyPluginSignature> = TSignatures extends readonly [plugin: infer P, ...otherPlugin: infer R] ? P extends TreeViewAnyPluginSignature ? P[TProperty] & MergeSignaturesProperty<R, TProperty> : {} : {};
+export type ConvertPluginsIntoSignatures<TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]> = TPlugins extends readonly [plugin: infer TPlugin, ...otherPlugin: infer R] ? R extends readonly TreeViewPlugin<any>[] ? TPlugin extends TreeViewPlugin<infer TSignature> ? readonly [TSignature, ...ConvertPluginsIntoSignatures<R>] : never : never : [];
+export type ConvertSignaturesIntoPlugins<TSignatures extends readonly TreeViewAnyPluginSignature[]> = TSignatures extends readonly [signature: infer TSignature, ...otherSignatures: infer R] ? R extends readonly TreeViewAnyPluginSignature[] ? TSignature extends TreeViewAnyPluginSignature ? readonly [TreeViewPlugin<TSignature>, ...ConvertSignaturesIntoPlugins<R>] : never : never : [];
+export {};

package/modern/internals/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./helpers.js";
+export * from "./plugin.js";
+export * from "./itemPlugin.js";
+export * from "./treeView.js";

package/modern/internals/models/itemPlugin.d.ts

@@ -0,0 +1,43 @@
+import * as React from 'react';
+import { EventHandlers } from '@mui/utils/types';
+import type { UseTreeItemContentSlotOwnProps, UseTreeItemDragAndDropOverlaySlotOwnProps, UseTreeItemLabelInputSlotOwnProps, UseTreeItemRootSlotOwnProps, UseTreeItemCheckboxSlotOwnProps, UseTreeItemLabelSlotOwnProps } from '../../useTreeItem';
+import type { UseTreeItemInteractions } from '../../hooks/useTreeItemUtils/useTreeItemUtils';
+import type { TreeItemProps } from '../../TreeItem/TreeItem.types';
+export interface TreeViewItemPluginSlotPropsEnhancerParams {
+  rootRefObject: React.RefObject<HTMLLIElement | null>;
+  contentRefObject: React.RefObject<HTMLDivElement | null>;
+  externalEventHandlers: EventHandlers;
+  interactions: UseTreeItemInteractions;
+}
+type TreeViewItemPluginSlotPropsEnhancer<TSlotProps> = (params: TreeViewItemPluginSlotPropsEnhancerParams) => Partial<TSlotProps>;
+export interface TreeViewItemPluginSlotPropsEnhancers {
+  root?: TreeViewItemPluginSlotPropsEnhancer<UseTreeItemRootSlotOwnProps>;
+  content?: TreeViewItemPluginSlotPropsEnhancer<UseTreeItemContentSlotOwnProps>;
+  dragAndDropOverlay?: TreeViewItemPluginSlotPropsEnhancer<UseTreeItemDragAndDropOverlaySlotOwnProps>;
+  labelInput?: TreeViewItemPluginSlotPropsEnhancer<UseTreeItemLabelInputSlotOwnProps>;
+  label?: TreeViewItemPluginSlotPropsEnhancer<UseTreeItemLabelSlotOwnProps>;
+  checkbox?: TreeViewItemPluginSlotPropsEnhancer<UseTreeItemCheckboxSlotOwnProps>;
+}
+export interface TreeViewItemPluginResponse {
+  /**
+   * Root of the `content` slot enriched by the plugin.
+   */
+  contentRef?: React.RefCallback<HTMLElement> | null;
+  /**
+   * Ref of the `root` slot enriched by the plugin
+   */
+  rootRef?: React.RefCallback<HTMLLIElement> | null;
+  /**
+   * Callback to enhance the slot props of the Tree Item.
+   *
+   * Not all slots are enabled by default,
+   * if a new plugin needs to pass to an un-configured slot,
+   * it just needs to be added to `TreeViewItemPluginSlotPropsEnhancers`
+   */
+  propsEnhancers?: TreeViewItemPluginSlotPropsEnhancers;
+}
+export interface TreeViewItemPluginOptions extends Omit<TreeViewItemPluginResponse, 'propsEnhancers'> {
+  props: TreeItemProps;
+}
+export type TreeViewItemPlugin = (options: TreeViewItemPluginOptions) => void | TreeViewItemPluginResponse;
+export {};