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

package/internals/models/plugin.d.ts

@@ -1,174 +1,151 @@
 import * as React from 'react';
 import { EventHandlers } from '@mui/utils/types';
-import { TreeViewExperimentalFeatures, TreeViewInstance, TreeViewModel } from './treeView';
+import { TreeViewExperimentalFeatures, TreeViewInstance, TreeViewModel } from "./treeView.js";
 import type { MergeSignaturesProperty, OptionalIfEmpty } from './helpers';
-import { TreeViewEventLookupElement } from './events';
+import { TreeViewEventLookupElement } from "./events.js";
 import type { TreeViewCorePluginSignatures } from '../corePlugins';
-import { TreeViewItemPlugin } from './itemPlugin';
-import { TreeViewItemId } from '../../models';
-import { TreeViewStore } from '../utils/TreeViewStore';
+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>[];
+  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 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>;
+  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?: {};
+  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'] : [];
+  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;
+  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 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'>;
+  /**
+   * 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;
+  itemId: TreeViewItemId;
+  children: React.ReactNode;
+  instance: TreeViewInstance<TSignatures>;
+  idAttribute: string;
 }) => React.ReactNode;
 export type TreeRootWrapper = (params: {
-    children: React.ReactNode;
+  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;
+  (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 {};
+export {};

package/internals/models/plugin.js

@@ -1 +1,5 @@
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/internals/models/treeView.d.ts

@@ -2,31 +2,31 @@ 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;
+  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;
+  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;
+  id: number;
 };
 export type TreeViewState<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'state'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'state'>> & {
-    cacheKey: TreeViewStateCacheKey;
-};
+  cacheKey: TreeViewStateCacheKey;
+};

package/internals/models/treeView.js

@@ -1 +1,5 @@
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

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

package/internals/plugins/useTreeViewExpansion/index.js

@@ -1 +1,12 @@
-export { useTreeViewExpansion } from "./useTreeViewExpansion.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useTreeViewExpansion", {
+  enumerable: true,
+  get: function () {
+    return _useTreeViewExpansion.useTreeViewExpansion;
+  }
+});
+var _useTreeViewExpansion = require("./useTreeViewExpansion");

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

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

package/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -1,33 +1,41 @@
-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 { selectorItemMeta, selectorItemOrderedChildrenIds } from "../useTreeViewItems/useTreeViewItems.selectors.js";
-export const useTreeViewExpansion = ({
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewExpansion = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedEffect"));
+var _useTreeViewExpansion = require("./useTreeViewExpansion.selectors");
+var _useTreeViewExpansion2 = require("./useTreeViewExpansion.utils");
+var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
+var _publishTreeViewEvent = require("../../utils/publishTreeViewEvent");
+const useTreeViewExpansion = ({
   instance,
   store,
   params,
   models
 }) => {
-  useEnhancedEffect(() => {
-    store.update(prevState => _extends({}, prevState, {
-      expansion: _extends({}, prevState.expansion, {
-        expandedItemsMap: createExpandedItemsMap(models.expandedItems.value)
+  (0, _useEnhancedEffect.default)(() => {
+    store.update(prevState => (0, _extends2.default)({}, prevState, {
+      expansion: (0, _extends2.default)({}, prevState.expansion, {
+        expandedItemsMap: (0, _useTreeViewExpansion2.createExpandedItemsMap)(models.expandedItems.value)
       })
     }));
   }, [store, models.expandedItems.value]);
-  useEnhancedEffect(() => {
+  (0, _useEnhancedEffect.default)(() => {
     store.update(prevState => {
-      const newExpansionTrigger = getExpansionTrigger({
+      const newExpansionTrigger = (0, _useTreeViewExpansion2.getExpansionTrigger)({
         isItemEditable: params.isItemEditable,
         expansionTrigger: params.expansionTrigger
       });
       if (prevState.expansion.expansionTrigger === newExpansionTrigger) {
         return prevState;
       }
-      return _extends({}, prevState, {
-        expansion: _extends({}, prevState.expansion, {
+      return (0, _extends2.default)({}, prevState, {
+        expansion: (0, _extends2.default)({}, prevState.expansion, {
           expansionTrigger: newExpansionTrigger
         })
       });
@@ -37,33 +45,55 @@ 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 = (0, _useEventCallback.default)(({
+    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 = (0, _useEventCallback.default)(({
+    itemId,
+    event = null,
+    shouldBeExpanded
+  }) => {
+    const isExpandedBefore = (0, _useTreeViewExpansion.selectorIsItemExpanded)(store.value, itemId);
+    const cleanShouldBeExpanded = shouldBeExpanded ?? !isExpandedBefore;
+    if (isExpandedBefore === cleanShouldBeExpanded) {
+      return;
+    }
+    const eventParameters = {
+      isExpansionPrevented: false,
+      shouldBeExpanded: cleanShouldBeExpanded,
+      event,
+      itemId
+    };
+    (0, _publishTreeViewEvent.publishTreeViewEvent)(instance, 'beforeItemToggleExpansion', eventParameters);
+    if (eventParameters.isExpansionPrevented) {
+      return;
+    }
+    instance.applyItemExpansion({
+      itemId,
+      event,
+      shouldBeExpanded: cleanShouldBeExpanded
+    });
+  });
   const expandAllSiblings = (event, itemId) => {
-    const itemMeta = selectorItemMeta(store.value, itemId);
+    const itemMeta = (0, _useTreeViewItems.selectorItemMeta)(store.value, itemId);
     if (itemMeta == null) {
       return;
     }
-    const siblings = selectorItemOrderedChildrenIds(store.value, itemMeta.parentId);
-    const diff = siblings.filter(child => selectorIsItemExpandable(store.value, child) && !selectorIsItemExpanded(store.value, child));
+    const siblings = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemMeta.parentId);
+    const diff = siblings.filter(child => (0, _useTreeViewExpansion.selectorIsItemExpandable)(store.value, child) && !(0, _useTreeViewExpansion.selectorIsItemExpanded)(store.value, child));
     const newExpanded = models.expandedItems.value.concat(diff);
     if (diff.length > 0) {
       if (params.onItemExpansionToggle) {
@@ -80,11 +110,12 @@ export const useTreeViewExpansion = ({
     },
     instance: {
       setItemExpansion,
-      toggleItemExpansion,
+      applyItemExpansion,
       expandAllSiblings
     }
   };
 };
+exports.useTreeViewExpansion = useTreeViewExpansion;
 useTreeViewExpansion.models = {
   expandedItems: {
     getDefaultValue: params => params.defaultExpandedItems
@@ -93,13 +124,13 @@ useTreeViewExpansion.models = {
 const DEFAULT_EXPANDED_ITEMS = [];
 useTreeViewExpansion.getDefaultizedParams = ({
   params
-}) => _extends({}, params, {
+}) => (0, _extends2.default)({}, params, {
   defaultExpandedItems: params.defaultExpandedItems ?? DEFAULT_EXPANDED_ITEMS
 });
 useTreeViewExpansion.getInitialState = params => ({
   expansion: {
-    expandedItemsMap: createExpandedItemsMap(params.expandedItems === undefined ? params.defaultExpandedItems : params.expandedItems),
-    expansionTrigger: getExpansionTrigger(params)
+    expandedItemsMap: (0, _useTreeViewExpansion2.createExpandedItemsMap)(params.expandedItems === undefined ? params.defaultExpandedItems : params.expandedItems),
+    expansionTrigger: (0, _useTreeViewExpansion2.getExpansionTrigger)(params)
   }
 });
 useTreeViewExpansion.params = {