@mui/x-tree-view 8.0.0-beta.2 → 8.0.0

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

@@ -1,11 +1,10 @@
 import * as React from 'react';
-import { MergeSignaturesProperty, TreeItemWrapper, TreeRootWrapper, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginResponse, TreeViewPublicAPI } from "../models/index.js";
+import { 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';
-import { TreeViewClasses } from "./TreeViewStyleContext.js";
+import { TreeViewClasses, TreeViewSlotProps, TreeViewSlots } from "./TreeViewStyleContext.js";
 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'>> & {
+export interface TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> {
   instance: TreeViewInstance<TSignatures, TOptionalSignatures>;
   publicAPI: TreeViewPublicAPI<TSignatures, TOptionalSignatures>;
   store: TreeViewStore<TSignatures>;
@@ -13,9 +12,11 @@ export type TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginS
   wrapItem: TreeItemWrapper<TSignatures>;
   wrapRoot: TreeRootWrapper;
   runItemPlugins: TreeViewItemPluginsRunner;
-};
+}
 export interface TreeViewProviderProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
   contextValue: TreeViewContextValue<TSignatures>;
   children: React.ReactNode;
   classes: Partial<TreeViewClasses> | undefined;
+  slots: TreeViewSlots | undefined;
+  slotProps: TreeViewSlotProps | undefined;
 }

package/esm/internals/TreeViewProvider/TreeViewStyleContext.d.ts

@@ -1,3 +1,4 @@
+import { SlotComponentProps } from '@mui/utils/types';
 import * as React from 'react';
 export interface TreeViewClasses {
   /** Styles applied to the root element. */
@@ -23,8 +24,30 @@ export interface TreeViewClasses {
   /** Styles applied to the item's loading icon element */
   itemLoadingIcon: string;
 }
+export interface TreeViewSlots {
+  /**
+   * The default icon used to collapse the item.
+   */
+  collapseIcon?: React.ElementType;
+  /**
+   * The default icon used to expand the item.
+   */
+  expandIcon?: React.ElementType;
+  /**
+   * The default icon displayed next to an end item.
+   * This is applied to all Tree Items and can be overridden by the TreeItem `icon` slot prop.
+   */
+  endIcon?: React.ElementType;
+}
+export interface TreeViewSlotProps {
+  collapseIcon?: SlotComponentProps<'svg', {}, {}>;
+  expandIcon?: SlotComponentProps<'svg', {}, {}>;
+  endIcon?: SlotComponentProps<'svg', {}, {}>;
+}
 export interface TreeViewStyleContextValue {
   classes: Partial<TreeViewClasses>;
+  slots: TreeViewSlots;
+  slotProps: TreeViewSlotProps;
 }
 /**
  * @ignore - internal component.

package/esm/internals/TreeViewProvider/TreeViewStyleContext.js

@@ -3,7 +3,9 @@ import * as React from 'react';
  * @ignore - internal component.
  */
 export const TreeViewStyleContext = /*#__PURE__*/React.createContext({
-  classes: {}
+  classes: {},
+  slots: {},
+  slotProps: {}
 });
 if (process.env.NODE_ENV !== 'production') {
   TreeViewStyleContext.displayName = 'TreeViewStyleContext';

package/esm/internals/hooks/useSelector.js

@@ -1,7 +1,4 @@
-// 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';
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector';
 const defaultCompare = Object.is;
 export const useSelector = (store, selector, args = undefined, equals = defaultCompare) => {
   const selectorWithArgs = state => selector(state, args);

package/esm/internals/index.d.ts

@@ -14,12 +14,11 @@ 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 { selectorIsItemBeingEdited, selectorIsAnyItemBeingEdited as selectorIsAnItemEdited } from "./plugins/useTreeViewLabel/useTreeViewLabel.selectors.js";
 export type { UseTreeViewLabelSignature, UseTreeViewLabelParameters } from './plugins/useTreeViewLabel';
 export { selectorIsItemExpanded } from "./plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
 export { selectorIsItemSelected } from "./plugins/useTreeViewSelection/useTreeViewSelection.selectors.js";
@@ -31,4 +30,4 @@ export type { UseTreeViewJSXItemsSignature, UseTreeViewJSXItemsParameters } from
 export { createSelector } from "./utils/selectors.js";
 export { isTargetInDescendants } from "./utils/tree.js";
 export { TreeViewStore } from "./utils/TreeViewStore.js";
-export type { TreeViewClasses } from './TreeViewProvider/TreeViewStyleContext';
+export type { TreeViewClasses, TreeViewSlots, TreeViewSlotProps } from './TreeViewProvider/TreeViewStyleContext';

package/esm/internals/index.js

@@ -11,10 +11,10 @@ export { useTreeViewExpansion } from "./plugins/useTreeViewExpansion/index.js";
 export { useTreeViewSelection } from "./plugins/useTreeViewSelection/index.js";
 export { useTreeViewFocus } from "./plugins/useTreeViewFocus/index.js";
 export { useTreeViewKeyboardNavigation } from "./plugins/useTreeViewKeyboardNavigation/index.js";
-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 { selectorIsItemBeingEdited, selectorIsAnyItemBeingEdited as selectorIsAnItemEdited } from "./plugins/useTreeViewLabel/useTreeViewLabel.selectors.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";

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

@@ -1,9 +1,5 @@
-import * as React from 'react';
+import { MuiEvent } from '@mui/x-internals/types';
 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;
-};
+export type TreeViewEventListener<E extends TreeViewEventLookupElement> = (params: E['params'], event: MuiEvent<{}>) => void;

package/esm/internals/models/plugin.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { EventHandlers } from '@mui/utils/types';
-import { TreeViewExperimentalFeatures, TreeViewInstance, TreeViewModel } from "./treeView.js";
+import { TreeViewExperimentalFeatures, TreeViewInstance } from "./treeView.js";
 import type { MergeSignaturesProperty, OptionalIfEmpty } from './helpers';
 import { TreeViewEventLookupElement } from "./events.js";
 import type { TreeViewCorePluginSignatures } from '../corePlugins';
@@ -8,22 +8,31 @@ import { TreeViewItemPlugin } from "./itemPlugin.js";
 import { TreeViewItemId } from "../../models/index.js";
 import { TreeViewStore } from "../utils/TreeViewStore.js";
 export interface TreeViewPluginOptions<TSignature extends TreeViewAnyPluginSignature> {
+  /**
+   * An imperative API available for internal use. Used to access methods from other plugins.
+   */
   instance: TreeViewUsedInstance<TSignature>;
+  /**
+   * The Tree View parameters after being processed with the default values.
+   */
   params: TreeViewUsedDefaultizedParams<TSignature>;
-  slots: TSignature['slots'];
-  slotProps: TSignature['slotProps'];
   experimentalFeatures: TreeViewUsedExperimentalFeatures<TSignature>;
-  models: TreeViewUsedModels<TSignature>;
+  /**
+   * The store that can be used to access the state of other plugins.
+   */
   store: TreeViewUsedStore<TSignature>;
+  /**
+   * Reference to the root element.
+   */
   rootRef: React.RefObject<HTMLUListElement | null>;
+  /**
+   * All the plugins that are used in the tree-view.
+   */
   plugins: TreeViewPlugin<TreeViewAnyPluginSignature>[];
 }
-type TreeViewModelsInitializer<TSignature extends TreeViewAnyPluginSignature> = { [TControlled in keyof TSignature['models']]: {
-  getDefaultValue: (params: TSignature['defaultizedParams']) => Exclude<TSignature['defaultizedParams'][TControlled], undefined>;
-} };
 type TreeViewResponse<TSignature extends TreeViewAnyPluginSignature> = {
   getRootProps?: <TOther extends EventHandlers = {}>(otherHandlers: TOther) => React.HTMLAttributes<HTMLUListElement>;
-} & OptionalIfEmpty<'publicAPI', TSignature['publicAPI']> & OptionalIfEmpty<'instance', TSignature['instance']> & OptionalIfEmpty<'contextValue', TSignature['contextValue']>;
+} & OptionalIfEmpty<'publicAPI', TSignature['publicAPI']> & OptionalIfEmpty<'instance', TSignature['instance']>;
 export type TreeViewPluginSignature<T extends {
   params?: {};
   defaultizedParams?: {};
@@ -31,61 +40,61 @@ export type TreeViewPluginSignature<T extends {
   publicAPI?: {};
   events?: { [key in keyof T['events']]: TreeViewEventLookupElement };
   state?: {};
-  cache?: {};
-  contextValue?: {};
-  slots?: { [key in keyof T['slots']]: React.ElementType };
-  slotProps?: { [key in keyof T['slotProps']]: {} | (() => {}) };
-  modelNames?: keyof T['defaultizedParams'];
   experimentalFeatures?: string;
   dependencies?: readonly TreeViewAnyPluginSignature[];
   optionalDependencies?: readonly TreeViewAnyPluginSignature[];
 }> = {
+  /**
+   * The raw properties that can be passed to the plugin.
+   */
   params: T extends {
     params: {};
   } ? T['params'] : {};
+  /**
+   * The params after being processed with the default values.
+   */
   defaultizedParams: T extends {
     defaultizedParams: {};
   } ? T['defaultizedParams'] : {};
+  /**
+   * An imperative api available for internal use.
+   */
   instance: T extends {
     instance: {};
   } ? T['instance'] : {};
+  /**
+   * The public imperative API that will be exposed to the user.
+   * Accessed through the `apiRef` property of the plugin.
+   */
   publicAPI: T extends {
     publicAPI: {};
   } ? T['publicAPI'] : {};
   events: T extends {
     events: {};
   } ? T['events'] : {};
+  /**
+   * The state is the mutable data that will actually be stored in the plugin state and can be accessed by other plugins.
+   */
   state: T extends {
     state: {};
   } ? T['state'] : {};
-  cache: T extends {
-    cache: {};
-  } ? T['cache'] : {};
-  contextValue: T extends {
-    contextValue: {};
-  } ? T['contextValue'] : {};
-  slots: T extends {
-    slots: {};
-  } ? T['slots'] : {};
-  slotProps: T extends {
-    slotProps: {};
-  } ? T['slotProps'] : {};
-  models: T extends {
-    defaultizedParams: {};
-    modelNames: keyof T['defaultizedParams'];
-  } ? { [TControlled in T['modelNames']]-?: TreeViewModel<Exclude<T['defaultizedParams'][TControlled], undefined>> } : {};
   experimentalFeatures: T extends {
     experimentalFeatures: string;
   } ? { [key in T['experimentalFeatures']]?: boolean } : {};
+  /**
+   * Any plugins that this plugin depends on.
+   */
   dependencies: T extends {
     dependencies: Array<any>;
   } ? T['dependencies'] : [];
+  /**
+   * Same as dependencies but the plugin might not have been initialized. Used for dependencies on plugins of features that can be enabled conditionally.
+   */
   optionalDependencies: T extends {
     optionalDependencies: Array<any>;
   } ? T['optionalDependencies'] : [];
 };
 export type TreeViewAnyPluginSignature = {
-  cache: any;
   state: any;
   instance: any;
   params: any;
@@ -93,10 +102,6 @@ export type TreeViewAnyPluginSignature = {
   dependencies: any;
   optionalDependencies: any;
   events: any;
-  contextValue: any;
-  slots: any;
-  slotProps: any;
-  models: any;
   experimentalFeatures: any;
   publicAPI: any;
 };
@@ -112,8 +117,6 @@ export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature>
 };
 export type TreeViewUsedStore<TSignature extends TreeViewAnyPluginSignature> = TreeViewStore<[TSignature, ...TSignature['dependencies']]>;
 type TreeViewUsedExperimentalFeatures<TSignature extends TreeViewAnyPluginSignature> = TreeViewExperimentalFeatures<[TSignature, ...TSignature['dependencies']], TSignature['optionalDependencies']>;
-type RemoveSetValue<Models extends Record<string, TreeViewModel<any>>> = { [K in keyof Models]: Omit<Models[K], 'setValue'> };
-export type TreeViewUsedModels<TSignature extends TreeViewAnyPluginSignature> = TSignature['models'] & RemoveSetValue<MergeSignaturesProperty<TreeViewRequiredPlugins<TSignature>, 'models'>>;
 export type TreeViewUsedEvents<TSignature extends TreeViewAnyPluginSignature> = TSignature['events'] & MergeSignaturesProperty<TreeViewRequiredPlugins<TSignature>, 'events'>;
 export type TreeItemWrapper<TSignatures extends readonly TreeViewAnyPluginSignature[]> = (params: {
   itemId: TreeViewItemId;
@@ -125,14 +128,36 @@ export type TreeRootWrapper = (params: {
   children: React.ReactNode;
 }) => React.ReactNode;
 export type TreeViewPlugin<TSignature extends TreeViewAnyPluginSignature> = {
+  /**
+   * The main function of the plugin that will be executed by the Tree View.
+   *
+   * This should be a valid React `use` function, as it will be executed in the render phase and can contain hooks.
+   */
   (options: TreeViewPluginOptions<TSignature>): TreeViewResponse<TSignature>;
+  /**
+   * A function that receives the parameters and returns them after being processed with the default values.
+   *
+   * @param {TreeViewUsedParams<TSignature>} options The options object.
+   * @param {TreeViewUsedParams<TSignature>['params']} options.params The parameters before being processed with the default values.
+   * @param {TreeViewUsedExperimentalFeatures<TSignature>} options.experimentalFeatures An object containing the experimental feature flags.
+   * @returns {TSignature['defaultizedParams']} The parameters after being processed with the default values.
+   */
   getDefaultizedParams?: (options: {
     params: TreeViewUsedParams<TSignature>;
     experimentalFeatures: TreeViewUsedExperimentalFeatures<TSignature>;
   }) => TSignature['defaultizedParams'];
+  /**
+   * The initial state is computed after the default values are applied.
+   * It sets up the state for the first render.
+   * Other state modifications have to be done in effects and so could not be applied on the initial render.
+   *
+   * @param {TreeViewUsedDefaultizedParams<TSignature>} params The parameters after being processed with the default values.
+   * @returns {TSignature['state']} The initial state of the plugin.
+   */
   getInitialState?: (params: TreeViewUsedDefaultizedParams<TSignature>) => TSignature['state'];
-  getInitialCache?: () => TSignature['cache'];
-  models?: TreeViewModelsInitializer<TSignature>;
+  /**
+   * An object where each property used by the plugin is set to `true`.
+   */
   params: Record<keyof TSignature['params'], true>;
   itemPlugin?: TreeViewItemPlugin;
   /**

package/esm/internals/models/treeView.d.ts

@@ -16,11 +16,6 @@ export interface TreeViewItemMeta {
    */
   label?: string;
 }
-export interface TreeViewModel<TValue> {
-  name: string;
-  value: TValue;
-  setControlledValue: (value: TValue | ((prevValue: TValue) => TValue)) => void;
-}
 export type TreeViewInstance<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'instance'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
 export type TreeViewPublicAPI<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'publicAPI'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
 export type TreeViewExperimentalFeatures<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TSignatures, ...TOptionalSignatures], 'experimentalFeatures'>;

package/esm/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -1,23 +1,21 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import useEventCallback from '@mui/utils/useEventCallback';
 import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
-import { selectorIsItemExpandable, selectorIsItemExpanded } from "./useTreeViewExpansion.selectors.js";
-import { createExpandedItemsMap, getExpansionTrigger } from "./useTreeViewExpansion.utils.js";
+import { selectorExpandedItems, selectorIsItemExpandable, selectorIsItemExpanded } from "./useTreeViewExpansion.selectors.js";
+import { getExpansionTrigger } from "./useTreeViewExpansion.utils.js";
 import { selectorItemMeta, selectorItemOrderedChildrenIds } from "../useTreeViewItems/useTreeViewItems.selectors.js";
 import { publishTreeViewEvent } from "../../utils/publishTreeViewEvent.js";
+import { useAssertModelConsistency } from "../../utils/models.js";
 export const useTreeViewExpansion = ({
   instance,
   store,
-  params,
-  models
+  params
 }) => {
-  useEnhancedEffect(() => {
-    store.update(prevState => _extends({}, prevState, {
-      expansion: _extends({}, prevState.expansion, {
-        expandedItemsMap: createExpandedItemsMap(models.expandedItems.value)
-      })
-    }));
-  }, [store, models.expandedItems.value]);
+  useAssertModelConsistency({
+    state: 'expandedItems',
+    controlled: params.expandedItems,
+    defaultValue: params.defaultExpandedItems
+  });
   useEnhancedEffect(() => {
     store.update(prevState => {
       const newExpansionTrigger = getExpansionTrigger({
@@ -35,19 +33,26 @@ export const useTreeViewExpansion = ({
     });
   }, [store, params.isItemEditable, params.expansionTrigger]);
   const setExpandedItems = (event, value) => {
+    if (params.expandedItems === undefined) {
+      store.update(prevState => _extends({}, prevState, {
+        expansion: _extends({}, prevState.expansion, {
+          expandedItems: value
+        })
+      }));
+    }
     params.onExpandedItemsChange?.(event, value);
-    models.expandedItems.setControlledValue(value);
   };
   const applyItemExpansion = useEventCallback(({
     itemId,
     event,
     shouldBeExpanded
   }) => {
+    const oldExpanded = selectorExpandedItems(store.value);
     let newExpanded;
     if (shouldBeExpanded) {
-      newExpanded = [itemId].concat(models.expandedItems.value);
+      newExpanded = [itemId].concat(oldExpanded);
     } else {
-      newExpanded = models.expandedItems.value.filter(id => id !== itemId);
+      newExpanded = oldExpanded.filter(id => id !== itemId);
     }
     if (params.onItemExpansionToggle) {
       params.onItemExpansionToggle(event, itemId, shouldBeExpanded);
@@ -87,7 +92,7 @@ export const useTreeViewExpansion = ({
     }
     const siblings = selectorItemOrderedChildrenIds(store.value, itemMeta.parentId);
     const diff = siblings.filter(child => selectorIsItemExpandable(store.value, child) && !selectorIsItemExpanded(store.value, child));
-    const newExpanded = models.expandedItems.value.concat(diff);
+    const newExpanded = selectorExpandedItems(store.value).concat(diff);
     if (diff.length > 0) {
       if (params.onItemExpansionToggle) {
         diff.forEach(newlyExpandedItemId => {
@@ -97,6 +102,20 @@ export const useTreeViewExpansion = ({
       setExpandedItems(event, newExpanded);
     }
   };
+
+  /**
+   * Update the controlled model when the `expandedItems` prop changes.
+   */
+  useEnhancedEffect(() => {
+    const expandedItems = params.expandedItems;
+    if (expandedItems !== undefined) {
+      store.update(prevState => _extends({}, prevState, {
+        expansion: _extends({}, prevState.expansion, {
+          expandedItems
+        })
+      }));
+    }
+  }, [store, params.expandedItems]);
   return {
     publicAPI: {
       setItemExpansion
@@ -108,11 +127,6 @@ export const useTreeViewExpansion = ({
     }
   };
 };
-useTreeViewExpansion.models = {
-  expandedItems: {
-    getDefaultValue: params => params.defaultExpandedItems
-  }
-};
 const DEFAULT_EXPANDED_ITEMS = [];
 useTreeViewExpansion.getDefaultizedParams = ({
   params
@@ -121,7 +135,7 @@ useTreeViewExpansion.getDefaultizedParams = ({
 });
 useTreeViewExpansion.getInitialState = params => ({
   expansion: {
-    expandedItemsMap: createExpandedItemsMap(params.expandedItems === undefined ? params.defaultExpandedItems : params.expandedItems),
+    expandedItems: params.expandedItems === undefined ? params.defaultExpandedItems : params.expandedItems,
     expansionTrigger: getExpansionTrigger(params)
   }
 });

package/esm/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.d.ts

@@ -1,29 +1,163 @@
 import { TreeViewRootSelector } from "../../utils/selectors.js";
 import { UseTreeViewExpansionSignature } from "./useTreeViewExpansion.types.js";
 /**
- * Check if an item is expanded.
+ * Get the expanded items.
  * @param {TreeViewState<[UseTreeViewExpansionSignature]>} state The state of the tree view.
- * @returns {boolean} `true` if the item is expanded, `false` otherwise.
+ * @returns {TreeViewItemId[]} The expanded items.
  */
-export declare const selectorIsItemExpanded: ((state: any, itemId: string) => boolean) & {
+export declare const selectorExpandedItems: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewExpansion.types").UseTreeViewExpansionState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => string[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
 } & {
   resultFunc: (resultFuncArgs_0: {
-    expandedItemsMap: Map<string, true>;
+    expandedItems: string[];
     expansionTrigger: "content" | "iconContainer";
-  }, resultFuncArgs_1: string) => boolean;
+  }) => string[];
   memoizedResultFunc: ((resultFuncArgs_0: {
-    expandedItemsMap: Map<string, true>;
+    expandedItems: string[];
     expansionTrigger: "content" | "iconContainer";
-  }, resultFuncArgs_1: string) => boolean) & {
+  }) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string[];
+  dependencies: [TreeViewRootSelector<UseTreeViewExpansionSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get the expanded items as a Map.
+ * @param {TreeViewState<[UseTreeViewExpansionSignature]>} state The state of the tree view.
+ * @returns {TreeViewExpansionValue} The expanded items as a Map.
+ */
+export declare const selectorExpandedItemsMap: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewExpansion.types").UseTreeViewExpansionState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => Map<string, true>) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: string[]) => Map<string, true>;
+  memoizedResultFunc: ((resultFuncArgs_0: string[]) => Map<string, true>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => Map<string, true>;
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewExpansion.types").UseTreeViewExpansionState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      expandedItems: string[];
+      expansionTrigger: "content" | "iconContainer";
+    }) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      expandedItems: string[];
+      expansionTrigger: "content" | "iconContainer";
+    }) => string[]) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [TreeViewRootSelector<UseTreeViewExpansionSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if an item is expanded.
+ * @param {TreeViewState<[UseTreeViewExpansionSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if the item is expanded, `false` otherwise.
+ */
+export declare const selectorIsItemExpanded: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: Map<string, true>, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: Map<string, true>, resultFuncArgs_1: string) => boolean) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
   };
   lastResult: () => boolean;
-  dependencies: [TreeViewRootSelector<UseTreeViewExpansionSignature>, (_: any, itemId: string) => string];
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewExpansion.types").UseTreeViewExpansionState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => Map<string, true>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: string[]) => Map<string, true>;
+    memoizedResultFunc: ((resultFuncArgs_0: string[]) => Map<string, true>) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => Map<string, true>;
+    dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewExpansion.types").UseTreeViewExpansionState & Partial<{}> & {
+      cacheKey: import("../../models").TreeViewStateCacheKey;
+    }) => string[]) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    } & {
+      resultFunc: (resultFuncArgs_0: {
+        expandedItems: string[];
+        expansionTrigger: "content" | "iconContainer";
+      }) => string[];
+      memoizedResultFunc: ((resultFuncArgs_0: {
+        expandedItems: string[];
+        expansionTrigger: "content" | "iconContainer";
+      }) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+      };
+      lastResult: () => string[];
+      dependencies: [TreeViewRootSelector<UseTreeViewExpansionSignature>];
+      recomputations: () => number;
+      resetRecomputations: () => void;
+      dependencyRecomputations: () => number;
+      resetDependencyRecomputations: () => void;
+    } & {
+      argsMemoize: typeof import("reselect").weakMapMemoize;
+      memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, (_: any, itemId: string) => string];
   recomputations: () => number;
   resetRecomputations: () => void;
   dependencyRecomputations: () => number;
@@ -161,11 +295,11 @@ export declare const selectorItemExpansionTrigger: ((state: import("../../corePl
   resetResultsCount: () => void;
 } & {
   resultFunc: (resultFuncArgs_0: {
-    expandedItemsMap: Map<string, true>;
+    expandedItems: string[];
     expansionTrigger: "content" | "iconContainer";
   }) => "content" | "iconContainer";
   memoizedResultFunc: ((resultFuncArgs_0: {
-    expandedItemsMap: Map<string, true>;
+    expandedItems: string[];
     expansionTrigger: "content" | "iconContainer";
   }) => "content" | "iconContainer") & {
     clearCache: () => void;