@mui/x-tree-view 8.0.0-alpha.8 → 8.0.0-beta.0

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

@@ -0,0 +1,151 @@
+import * as React from 'react';
+import { EventHandlers } from '@mui/utils/types';
+import { TreeViewExperimentalFeatures, TreeViewInstance, TreeViewModel } from "./treeView.js";
+import type { MergeSignaturesProperty, OptionalIfEmpty } from './helpers';
+import { TreeViewEventLookupElement } from "./events.js";
+import type { TreeViewCorePluginSignatures } from '../corePlugins';
+import { TreeViewItemPlugin } from "./itemPlugin.js";
+import { TreeViewItemId } from "../../models/index.js";
+import { TreeViewStore } from "../utils/TreeViewStore.js";
+export interface TreeViewPluginOptions<TSignature extends TreeViewAnyPluginSignature> {
+  instance: TreeViewUsedInstance<TSignature>;
+  params: TreeViewUsedDefaultizedParams<TSignature>;
+  slots: TSignature['slots'];
+  slotProps: TSignature['slotProps'];
+  experimentalFeatures: TreeViewUsedExperimentalFeatures<TSignature>;
+  models: TreeViewUsedModels<TSignature>;
+  store: TreeViewUsedStore<TSignature>;
+  rootRef: React.RefObject<HTMLUListElement | null>;
+  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']>;
+export type TreeViewPluginSignature<T extends {
+  params?: {};
+  defaultizedParams?: {};
+  instance?: {};
+  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[];
+}> = {
+  params: T extends {
+    params: {};
+  } ? T['params'] : {};
+  defaultizedParams: T extends {
+    defaultizedParams: {};
+  } ? T['defaultizedParams'] : {};
+  instance: T extends {
+    instance: {};
+  } ? T['instance'] : {};
+  publicAPI: T extends {
+    publicAPI: {};
+  } ? T['publicAPI'] : {};
+  events: T extends {
+    events: {};
+  } ? T['events'] : {};
+  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 } : {};
+  dependencies: T extends {
+    dependencies: Array<any>;
+  } ? T['dependencies'] : [];
+  optionalDependencies: T extends {
+    optionalDependencies: Array<any>;
+  } ? T['optionalDependencies'] : [];
+};
+export type TreeViewAnyPluginSignature = {
+  cache: any;
+  state: any;
+  instance: any;
+  params: any;
+  defaultizedParams: any;
+  dependencies: any;
+  optionalDependencies: any;
+  events: any;
+  contextValue: any;
+  slots: any;
+  slotProps: any;
+  models: any;
+  experimentalFeatures: any;
+  publicAPI: any;
+};
+type TreeViewRequiredPlugins<TSignature extends TreeViewAnyPluginSignature> = [...TreeViewCorePluginSignatures, ...TSignature['dependencies']];
+type PluginPropertyWithDependencies<TSignature extends TreeViewAnyPluginSignature, TProperty extends keyof TreeViewAnyPluginSignature> = TSignature[TProperty] & MergeSignaturesProperty<TreeViewRequiredPlugins<TSignature>, TProperty> & Partial<MergeSignaturesProperty<TSignature['optionalDependencies'], TProperty>>;
+export type TreeViewUsedParams<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'params'>;
+export type TreeViewUsedDefaultizedParams<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'defaultizedParams'>;
+export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'instance'> & {
+  /**
+   * Private property only defined in TypeScript to be able to access the plugin signature from the instance object.
+   */
+  $$signature: TSignature;
+};
+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;
+  children: React.ReactNode;
+  instance: TreeViewInstance<TSignatures>;
+  idAttribute: string;
+}) => React.ReactNode;
+export type TreeRootWrapper = (params: {
+  children: React.ReactNode;
+}) => React.ReactNode;
+export type TreeViewPlugin<TSignature extends TreeViewAnyPluginSignature> = {
+  (options: TreeViewPluginOptions<TSignature>): TreeViewResponse<TSignature>;
+  getDefaultizedParams?: (options: {
+    params: TreeViewUsedParams<TSignature>;
+    experimentalFeatures: TreeViewUsedExperimentalFeatures<TSignature>;
+  }) => TSignature['defaultizedParams'];
+  getInitialState?: (params: TreeViewUsedDefaultizedParams<TSignature>) => TSignature['state'];
+  getInitialCache?: () => TSignature['cache'];
+  models?: TreeViewModelsInitializer<TSignature>;
+  params: Record<keyof TSignature['params'], true>;
+  itemPlugin?: TreeViewItemPlugin;
+  /**
+   * Render function used to add React wrappers around the TreeItem.
+   * @param {{ nodeId: TreeViewItemId; children: React.ReactNode; }} params The params of the item.
+   * @returns {React.ReactNode} The wrapped item.
+   */
+  wrapItem?: TreeItemWrapper<[TSignature, ...TSignature['dependencies']]>;
+  /**
+   * Render function used to add React wrappers around the TreeView.
+   * @param {{ children: React.ReactNode; }} params The params of the root.
+   * @returns {React.ReactNode} The wrapped root.
+   */
+  wrapRoot?: TreeRootWrapper;
+};
+export {};

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

@@ -0,0 +1,32 @@
+import type { TreeViewAnyPluginSignature } from './plugin';
+import type { MergeSignaturesProperty } from './helpers';
+import type { TreeViewCorePluginSignatures } from '../corePlugins';
+export interface TreeViewItemMeta {
+  id: string;
+  idAttribute: string | undefined;
+  parentId: string | null;
+  expandable: boolean;
+  disabled: boolean;
+  /**
+   * Only defined for `<RichTreeView />` and `<RichTreeViewPro />`.
+   */
+  depth?: number;
+  /**
+   * Only defined for `<RichTreeView />` and `<RichTreeViewPro />`.
+   */
+  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'>;
+export type TreeViewStateCacheKey = {
+  id: number;
+};
+export type TreeViewState<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'state'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'state'>> & {
+  cacheKey: TreeViewStateCacheKey;
+};

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

@@ -0,0 +1,2 @@
+export { useTreeViewExpansion } from "./useTreeViewExpansion.js";
+export type { UseTreeViewExpansionSignature, UseTreeViewExpansionParameters, UseTreeViewExpansionDefaultizedParameters } from './useTreeViewExpansion.types';

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

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

package/modern/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -4,6 +4,7 @@ import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
 import { selectorIsItemExpandable, selectorIsItemExpanded } from "./useTreeViewExpansion.selectors.js";
 import { createExpandedItemsMap, getExpansionTrigger } from "./useTreeViewExpansion.utils.js";
 import { selectorItemMeta, selectorItemOrderedChildrenIds } from "../useTreeViewItems/useTreeViewItems.selectors.js";
+import { publishTreeViewEvent } from "../../utils/publishTreeViewEvent.js";
 export const useTreeViewExpansion = ({
   instance,
   store,
@@ -37,26 +38,48 @@ export const useTreeViewExpansion = ({
     params.onExpandedItemsChange?.(event, value);
     models.expandedItems.setControlledValue(value);
   };
-  const toggleItemExpansion = useEventCallback((event, itemId) => {
-    const isExpandedBefore = selectorIsItemExpanded(store.value, itemId);
-    instance.setItemExpansion(event, itemId, !isExpandedBefore);
-  });
-  const setItemExpansion = useEventCallback((event, itemId, isExpanded) => {
-    const isExpandedBefore = selectorIsItemExpanded(store.value, itemId);
-    if (isExpandedBefore === isExpanded) {
-      return;
-    }
+  const applyItemExpansion = useEventCallback(({
+    itemId,
+    event,
+    shouldBeExpanded
+  }) => {
     let newExpanded;
-    if (isExpanded) {
+    if (shouldBeExpanded) {
       newExpanded = [itemId].concat(models.expandedItems.value);
     } else {
       newExpanded = models.expandedItems.value.filter(id => id !== itemId);
     }
     if (params.onItemExpansionToggle) {
-      params.onItemExpansionToggle(event, itemId, isExpanded);
+      params.onItemExpansionToggle(event, itemId, shouldBeExpanded);
     }
     setExpandedItems(event, newExpanded);
   });
+  const setItemExpansion = useEventCallback(({
+    itemId,
+    event = null,
+    shouldBeExpanded
+  }) => {
+    const isExpandedBefore = selectorIsItemExpanded(store.value, itemId);
+    const cleanShouldBeExpanded = shouldBeExpanded ?? !isExpandedBefore;
+    if (isExpandedBefore === cleanShouldBeExpanded) {
+      return;
+    }
+    const eventParameters = {
+      isExpansionPrevented: false,
+      shouldBeExpanded: cleanShouldBeExpanded,
+      event,
+      itemId
+    };
+    publishTreeViewEvent(instance, 'beforeItemToggleExpansion', eventParameters);
+    if (eventParameters.isExpansionPrevented) {
+      return;
+    }
+    instance.applyItemExpansion({
+      itemId,
+      event,
+      shouldBeExpanded: cleanShouldBeExpanded
+    });
+  });
   const expandAllSiblings = (event, itemId) => {
     const itemMeta = selectorItemMeta(store.value, itemId);
     if (itemMeta == null) {
@@ -80,7 +103,7 @@ export const useTreeViewExpansion = ({
     },
     instance: {
       setItemExpansion,
-      toggleItemExpansion,
+      applyItemExpansion,
       expandAllSiblings
     }
   };

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

@@ -0,0 +1,184 @@
+import { TreeViewRootSelector } from "../../utils/selectors.js";
+import { UseTreeViewExpansionSignature } from "./useTreeViewExpansion.types.js";
+/**
+ * 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: {
+    expandedItemsMap: Map<string, true>;
+    expansionTrigger: "content" | "iconContainer";
+  }, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    expandedItemsMap: Map<string, true>;
+    expansionTrigger: "content" | "iconContainer";
+  }, resultFuncArgs_1: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelector<UseTreeViewExpansionSignature>, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if an item is expandable.
+ * @param {TreeViewState<[UseTreeViewItemsSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if the item is expandable, `false` otherwise.
+ */
+export declare const selectorIsItemExpandable: ((state: any, itemId: string | null) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: import("../..").TreeViewItemMeta | null) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: import("../..").TreeViewItemMeta | null) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [((state: any, itemId: string | null) => import("../..").TreeViewItemMeta | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      [itemId: string]: import("../..").TreeViewItemMeta;
+    }, resultFuncArgs_1: string | null) => import("../..").TreeViewItemMeta | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      [itemId: string]: import("../..").TreeViewItemMeta;
+    }, resultFuncArgs_1: string | null) => import("../..").TreeViewItemMeta | null) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => import("../..").TreeViewItemMeta | null;
+    dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("../useTreeViewItems").UseTreeViewItemsState<import("../../..").TreeViewDefaultItemModelProperties> & Partial<{}> & {
+      cacheKey: import("../../models").TreeViewStateCacheKey;
+    }) => {
+      [itemId: string]: import("../..").TreeViewItemMeta;
+    }) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    } & {
+      resultFunc: (resultFuncArgs_0: {
+        disabledItemsFocusable: boolean;
+        itemModelLookup: {
+          [itemId: string]: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>;
+        };
+        itemMetaLookup: {
+          [itemId: string]: import("../..").TreeViewItemMeta;
+        };
+        itemOrderedChildrenIdsLookup: {
+          [parentItemId: string]: string[];
+        };
+        itemChildrenIndexesLookup: {
+          [parentItemId: string]: {
+            [itemId: string]: number;
+          };
+        };
+        loading: boolean;
+        error: Error | null;
+      }) => {
+        [itemId: string]: import("../..").TreeViewItemMeta;
+      };
+      memoizedResultFunc: ((resultFuncArgs_0: {
+        disabledItemsFocusable: boolean;
+        itemModelLookup: {
+          [itemId: string]: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>;
+        };
+        itemMetaLookup: {
+          [itemId: string]: import("../..").TreeViewItemMeta;
+        };
+        itemOrderedChildrenIdsLookup: {
+          [parentItemId: string]: string[];
+        };
+        itemChildrenIndexesLookup: {
+          [parentItemId: string]: {
+            [itemId: string]: number;
+          };
+        };
+        loading: boolean;
+        error: Error | null;
+      }) => {
+        [itemId: string]: import("../..").TreeViewItemMeta;
+      }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+      };
+      lastResult: () => {
+        [itemId: string]: import("../..").TreeViewItemMeta;
+      };
+      dependencies: [TreeViewRootSelector<import("../useTreeViewItems").UseTreeViewItemsSignature>];
+      recomputations: () => number;
+      resetRecomputations: () => void;
+      dependencyRecomputations: () => number;
+      resetDependencyRecomputations: () => void;
+    } & {
+      argsMemoize: typeof import("reselect").weakMapMemoize;
+      memoize: typeof import("reselect").weakMapMemoize;
+    }, (_: any, itemId: string | null) => string | null];
+    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;
+};
+/**
+ * Get the slot that triggers the item's expansion when clicked.
+ * @param {TreeViewState<[UseTreeViewExpansionSignature]>} state The state of the tree view.
+ * @returns {'content' | 'iconContainer'} The slot that triggers the item's expansion when clicked. Is `null` if the item is not expandable.
+ */
+export declare const selectorItemExpansionTrigger: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewExpansion.types").UseTreeViewExpansionState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => "content" | "iconContainer") & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    expandedItemsMap: Map<string, true>;
+    expansionTrigger: "content" | "iconContainer";
+  }) => "content" | "iconContainer";
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    expandedItemsMap: Map<string, true>;
+    expansionTrigger: "content" | "iconContainer";
+  }) => "content" | "iconContainer") & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => "content" | "iconContainer";
+  dependencies: [TreeViewRootSelector<UseTreeViewExpansionSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

package/modern/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.types.d.ts

@@ -0,0 +1,102 @@
+import * as React from 'react';
+import { DefaultizedProps } from '@mui/x-internals/types';
+import { TreeViewPluginSignature } from "../../models/index.js";
+import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
+import { TreeViewItemId } from "../../../models/index.js";
+import { UseTreeViewLabelSignature } from "../useTreeViewLabel/index.js";
+export interface UseTreeViewExpansionPublicAPI {
+  /**
+   * Change the expansion status of a given item.
+   * @param {object} parameters The parameters of the method.
+   * @param {string} parameters.itemId The id of the item to expand of collapse.
+   * @param {React.SyntheticEvent} parameters.event The DOM event that triggered the change.
+   * @param {boolean} parameters.shouldBeExpanded If `true` the item will be expanded. If `false` the item will be collapsed. If not defined, the item's expansion status will be the toggled.
+   */
+  setItemExpansion: (parameters: {
+    itemId: string;
+    event?: React.SyntheticEvent;
+    shouldBeExpanded?: boolean;
+  }) => void;
+}
+export interface UseTreeViewExpansionInstance extends UseTreeViewExpansionPublicAPI {
+  /**
+   * Expand all the siblings (i.e.: the items that have the same parent) of a given item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} itemId The id of the item whose siblings will be expanded.
+   */
+  expandAllSiblings: (event: React.KeyboardEvent, itemId: TreeViewItemId) => void;
+  /**
+   * APply the new expansion status of a given item.
+   * Is used by the `setItemExpansion` method and by the `useTreeViewLazyLoading` plugin.
+   * Unlike `setItemExpansion`, this method does not trigger the lazy loading.
+   * @param {object} parameters The parameters of the method.
+   * @param {string} parameters.itemId The id of the item to expand of collapse.
+   * @param {React.SyntheticEvent | null} parameters.event The DOM event that triggered the change.
+   * @param {boolean} parameters.shouldBeExpanded If `true` the item will be expanded. If `false` the item will be collapsed.
+   */
+  applyItemExpansion: (parameters: {
+    itemId: string;
+    event: React.SyntheticEvent | null;
+    shouldBeExpanded: boolean;
+  }) => void;
+}
+export interface UseTreeViewExpansionParameters {
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is controlled.
+   */
+  expandedItems?: string[];
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is not controlled.
+   * @default []
+   */
+  defaultExpandedItems?: string[];
+  /**
+   * Callback fired when Tree Items are expanded/collapsed.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemExpansion()` method.
+   * @param {array} itemIds The ids of the expanded items.
+   */
+  onExpandedItemsChange?: (event: React.SyntheticEvent | null, itemIds: string[]) => void;
+  /**
+   * Callback fired when a Tree Item is expanded or collapsed.
+   * @param {React.SyntheticEvent | null} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemExpansion()` method.
+   * @param {array} itemId The itemId of the modified item.
+   * @param {array} isExpanded `true` if the item has just been expanded, `false` if it has just been collapsed.
+   */
+  onItemExpansionToggle?: (event: React.SyntheticEvent | null, itemId: string, isExpanded: boolean) => void;
+  /**
+   * The slot that triggers the item's expansion when clicked.
+   * @default 'content'
+   */
+  expansionTrigger?: 'content' | 'iconContainer';
+}
+export type UseTreeViewExpansionDefaultizedParameters = DefaultizedProps<UseTreeViewExpansionParameters, 'defaultExpandedItems'>;
+export interface UseTreeViewExpansionState {
+  expansion: {
+    expandedItemsMap: Map<string, true>;
+    expansionTrigger: 'content' | 'iconContainer';
+  };
+}
+interface UseTreeViewExpansionEventLookup {
+  beforeItemToggleExpansion: {
+    params: {
+      isExpansionPrevented: boolean;
+      shouldBeExpanded: boolean;
+      event: React.SyntheticEvent | null;
+      itemId: TreeViewItemId;
+    };
+  };
+}
+export type UseTreeViewExpansionSignature = TreeViewPluginSignature<{
+  params: UseTreeViewExpansionParameters;
+  defaultizedParams: UseTreeViewExpansionDefaultizedParameters;
+  instance: UseTreeViewExpansionInstance;
+  publicAPI: UseTreeViewExpansionPublicAPI;
+  modelNames: 'expandedItems';
+  state: UseTreeViewExpansionState;
+  dependencies: [UseTreeViewItemsSignature];
+  optionalDependencies: [UseTreeViewLabelSignature];
+  events: UseTreeViewExpansionEventLookup;
+}>;
+export {};

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

@@ -0,0 +1,7 @@
+import { TreeViewUsedDefaultizedParams } from "../../models/index.js";
+import { UseTreeViewExpansionSignature } from "./useTreeViewExpansion.types.js";
+export declare const createExpandedItemsMap: (expandedItems: string[]) => Map<string, true>;
+export declare const getExpansionTrigger: ({
+  isItemEditable,
+  expansionTrigger
+}: Pick<TreeViewUsedDefaultizedParams<UseTreeViewExpansionSignature>, "isItemEditable" | "expansionTrigger">) => "content" | "iconContainer";

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

@@ -0,0 +1,2 @@
+export { useTreeViewFocus } from "./useTreeViewFocus.js";
+export type { UseTreeViewFocusSignature, UseTreeViewFocusParameters, UseTreeViewFocusDefaultizedParameters } from './useTreeViewFocus.types';

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

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