@mui/x-tree-view 8.22.0 → 8.24.0

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

@@ -1,22 +0,0 @@
-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/internals/corePlugins/useTreeViewOptionalPlugins/index.d.ts

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

package/internals/corePlugins/useTreeViewOptionalPlugins/index.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "useTreeViewOptionalPlugins", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewOptionalPlugins.useTreeViewOptionalPlugins;
-  }
-});
-var _useTreeViewOptionalPlugins = require("./useTreeViewOptionalPlugins");

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

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

package/internals/corePlugins/useTreeViewOptionalPlugins/useTreeViewOptionalPlugins.js

@@ -1,19 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTreeViewOptionalPlugins = void 0;
-const useTreeViewOptionalPlugins = ({
-  plugins
-}) => {
-  const pluginSet = new Set(plugins);
-  const getAvailablePlugins = () => pluginSet;
-  return {
-    instance: {
-      getAvailablePlugins
-    }
-  };
-};
-exports.useTreeViewOptionalPlugins = useTreeViewOptionalPlugins;
-useTreeViewOptionalPlugins.params = {};

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

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

package/internals/hooks/useInstanceEventHandler.d.ts

@@ -1,15 +0,0 @@
-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/internals/hooks/useInstanceEventHandler.js

@@ -1,87 +0,0 @@
-"use strict";
-'use client';
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createUseInstanceEventHandler = createUseInstanceEventHandler;
-exports.useInstanceEventHandler = exports.unstable_resetCleanupTracking = void 0;
-var React = _interopRequireWildcard(require("react"));
-var _TimerBasedCleanupTracking = require("../utils/cleanupTracking/TimerBasedCleanupTracking");
-var _FinalizationRegistryBasedCleanupTracking = require("../utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking");
-// We use class to make it easier to detect in heap snapshots by name
-class ObjectToBeRetainedByReact {}
-
-// Based on https://github.com/Bnaya/use-dispose-uncommitted/blob/main/src/finalization-registry-based-impl.ts
-// Check https://github.com/facebook/react/issues/15317 to get more information
-function createUseInstanceEventHandler(registryContainer) {
-  let cleanupTokensCounter = 0;
-  return function useInstanceEventHandler(instance, eventName, handler) {
-    if (registryContainer.registry === null) {
-      registryContainer.registry = typeof FinalizationRegistry !== 'undefined' ? new _FinalizationRegistryBasedCleanupTracking.FinalizationRegistryBasedCleanupTracking() : new _TimerBasedCleanupTracking.TimerBasedCleanupTracking();
-    }
-    const [objectRetainedByReact] = React.useState(new ObjectToBeRetainedByReact());
-    const subscription = React.useRef(null);
-    const handlerRef = React.useRef(undefined);
-    handlerRef.current = handler;
-    const cleanupTokenRef = React.useRef(null);
-    if (!subscription.current && handlerRef.current) {
-      const enhancedHandler = (params, event) => {
-        if (!event.defaultMuiPrevented) {
-          handlerRef.current?.(params, event);
-        }
-      };
-      subscription.current = instance.$$subscribeEvent(eventName, enhancedHandler);
-      cleanupTokensCounter += 1;
-      cleanupTokenRef.current = {
-        cleanupToken: cleanupTokensCounter
-      };
-      registryContainer.registry.register(objectRetainedByReact,
-      // The callback below will be called once this reference stops being retained
-      () => {
-        subscription.current?.();
-        subscription.current = null;
-        cleanupTokenRef.current = null;
-      }, cleanupTokenRef.current);
-    } else if (!handlerRef.current && subscription.current) {
-      subscription.current();
-      subscription.current = null;
-      if (cleanupTokenRef.current) {
-        registryContainer.registry.unregister(cleanupTokenRef.current);
-        cleanupTokenRef.current = null;
-      }
-    }
-    React.useEffect(() => {
-      if (!subscription.current && handlerRef.current) {
-        const enhancedHandler = (params, event) => {
-          if (!event.defaultMuiPrevented) {
-            handlerRef.current?.(params, event);
-          }
-        };
-        subscription.current = instance.$$subscribeEvent(eventName, enhancedHandler);
-      }
-      if (cleanupTokenRef.current && registryContainer.registry) {
-        // If the effect was called, it means that this render was committed
-        // so we can trust the cleanup function to remove the listener.
-        registryContainer.registry.unregister(cleanupTokenRef.current);
-        cleanupTokenRef.current = null;
-      }
-      return () => {
-        subscription.current?.();
-        subscription.current = null;
-      };
-    }, [instance, eventName]);
-  };
-}
-const registryContainer = {
-  registry: null
-};
-
-// eslint-disable-next-line @typescript-eslint/naming-convention
-const unstable_resetCleanupTracking = () => {
-  registryContainer.registry?.reset();
-  registryContainer.registry = null;
-};
-exports.unstable_resetCleanupTracking = unstable_resetCleanupTracking;
-const useInstanceEventHandler = exports.useInstanceEventHandler = createUseInstanceEventHandler(registryContainer);

package/internals/models/helpers.d.ts

@@ -1,7 +0,0 @@
-import type { TreeViewAnyPluginSignature, TreeViewPlugin } from "./plugin.js";
-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/internals/models/plugin.d.ts

@@ -1,166 +0,0 @@
-import * as React from 'react';
-import { EventHandlers } from '@mui/utils/types';
-import { TreeViewInstance, TreeViewStore } from "./treeView.js";
-import type { MergeSignaturesProperty, OptionalIfEmpty } from "./helpers.js";
-import { TreeViewEventLookupElement } from "./events.js";
-import type { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
-import { TreeViewItemPlugin } from "./itemPlugin.js";
-import { TreeViewItemId } from "../../models/index.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: TreeViewUsedParamsWithDefaults<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 TreeViewResponse<TSignature extends TreeViewAnyPluginSignature> = {
-  getRootProps?: <TOther extends EventHandlers = {}>(otherHandlers: TOther) => React.HTMLAttributes<HTMLUListElement>;
-} & OptionalIfEmpty<'publicAPI', TSignature['publicAPI']> & OptionalIfEmpty<'instance', TSignature['instance']>;
-export type TreeViewPluginSignature<T extends {
-  params?: {};
-  paramsWithDefaults?: {};
-  instance?: {};
-  publicAPI?: {};
-  events?: { [key in keyof T['events']]: TreeViewEventLookupElement };
-  state?: {};
-  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.
-   */
-  paramsWithDefaults: T extends {
-    paramsWithDefaults: {};
-  } ? T['paramsWithDefaults'] : {};
-  /**
-   * 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'] : {};
-  /**
-   * 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 = {
-  state: any;
-  instance: any;
-  params: any;
-  paramsWithDefaults: any;
-  dependencies: any;
-  optionalDependencies: any;
-  events: 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 TreeViewUsedParamsWithDefaults<TSignature extends TreeViewAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'paramsWithDefaults'>;
-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']], TSignature['optionalDependencies']>;
-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> = {
-  /**
-   * 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.
-   * @returns {TSignature['paramsWithDefaults']} The parameters after being processed with the default values.
-   */
-  applyDefaultValuesToParams?: (options: {
-    params: TreeViewUsedParams<TSignature>;
-  }) => TSignature['paramsWithDefaults'];
-  /**
-   * 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 {TreeViewUsedParamsWithDefaults<TSignature>} params The parameters after being processed with the default values.
-   * @returns {TSignature['state']} The initial state of the plugin.
-   */
-  getInitialState?: (params: TreeViewUsedParamsWithDefaults<TSignature>) => TSignature['state'];
-  /**
-   * An object where each property used by the plugin is set to `true`.
-   */
-  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/internals/models/plugin.js

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

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

@@ -1,3 +0,0 @@
-export { useTreeViewExpansion } from "./useTreeViewExpansion.js";
-export type { UseTreeViewExpansionSignature, UseTreeViewExpansionParameters, UseTreeViewExpansionParametersWithDefaults } from "./useTreeViewExpansion.types.js";
-export { expansionSelectors } from "./useTreeViewExpansion.selectors.js";

package/internals/plugins/useTreeViewExpansion/index.js

@@ -1,19 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "expansionSelectors", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewExpansion2.expansionSelectors;
-  }
-});
-Object.defineProperty(exports, "useTreeViewExpansion", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewExpansion.useTreeViewExpansion;
-  }
-});
-var _useTreeViewExpansion = require("./useTreeViewExpansion");
-var _useTreeViewExpansion2 = require("./useTreeViewExpansion.selectors");

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

@@ -1,3 +0,0 @@
-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,157 +0,0 @@
-"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 _useAssertModelConsistency = require("@mui/x-internals/useAssertModelConsistency");
-var _useEventCallback = require("@base-ui-components/utils/useEventCallback");
-var _useIsoLayoutEffect = require("@base-ui-components/utils/useIsoLayoutEffect");
-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
-}) => {
-  (0, _useAssertModelConsistency.useAssertModelConsistency)({
-    componentName: 'Tree View',
-    propName: 'expandedItems',
-    controlled: params.expandedItems,
-    defaultValue: params.defaultExpandedItems
-  });
-  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => {
-    const newExpansionTrigger = (0, _useTreeViewExpansion2.getExpansionTrigger)({
-      isItemEditable: params.isItemEditable,
-      expansionTrigger: params.expansionTrigger
-    });
-    if (store.state.expansion.expansionTrigger === newExpansionTrigger) {
-      return;
-    }
-    store.set('expansion', (0, _extends2.default)({}, store.state.expansion, {
-      expansionTrigger: newExpansionTrigger
-    }));
-  }, [store, params.isItemEditable, params.expansionTrigger]);
-  const setExpandedItems = (event, value) => {
-    if (params.expandedItems === undefined) {
-      store.set('expansion', (0, _extends2.default)({}, store.state.expansion, {
-        expandedItems: value
-      }));
-    }
-    params.onExpandedItemsChange?.(event, value);
-  };
-  const resetItemExpansion = (0, _useEventCallback.useEventCallback)(() => {
-    setExpandedItems(null, []);
-  });
-  const applyItemExpansion = (0, _useEventCallback.useEventCallback)(({
-    itemId,
-    event,
-    shouldBeExpanded
-  }) => {
-    const oldExpanded = _useTreeViewExpansion.expansionSelectors.expandedItemsRaw(store.state);
-    let newExpanded;
-    if (shouldBeExpanded) {
-      newExpanded = [itemId].concat(oldExpanded);
-    } else {
-      newExpanded = oldExpanded.filter(id => id !== itemId);
-    }
-    if (params.onItemExpansionToggle) {
-      params.onItemExpansionToggle(event, itemId, shouldBeExpanded);
-    }
-    setExpandedItems(event, newExpanded);
-  });
-  const setItemExpansion = (0, _useEventCallback.useEventCallback)(({
-    itemId,
-    event = null,
-    shouldBeExpanded
-  }) => {
-    const isExpandedBefore = _useTreeViewExpansion.expansionSelectors.isItemExpanded(store.state, 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 isItemExpanded = (0, _useEventCallback.useEventCallback)(itemId => {
-    return _useTreeViewExpansion.expansionSelectors.isItemExpanded(store.state, itemId);
-  });
-  const expandAllSiblings = (event, itemId) => {
-    const itemMeta = _useTreeViewItems.itemsSelectors.itemMeta(store.state, itemId);
-    if (itemMeta == null) {
-      return;
-    }
-    const siblings = _useTreeViewItems.itemsSelectors.itemOrderedChildrenIds(store.state, itemMeta.parentId);
-    const diff = siblings.filter(child => _useTreeViewExpansion.expansionSelectors.isItemExpandable(store.state, child) && !_useTreeViewExpansion.expansionSelectors.isItemExpanded(store.state, child));
-    const newExpanded = _useTreeViewExpansion.expansionSelectors.expandedItemsRaw(store.state).concat(diff);
-    if (diff.length > 0) {
-      if (params.onItemExpansionToggle) {
-        diff.forEach(newlyExpandedItemId => {
-          params.onItemExpansionToggle(event, newlyExpandedItemId, true);
-        });
-      }
-      setExpandedItems(event, newExpanded);
-    }
-  };
-
-  /**
-   * Update the controlled model when the `expandedItems` prop changes.
-   */
-  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => {
-    const expandedItems = params.expandedItems;
-    if (expandedItems !== undefined) {
-      store.set('expansion', (0, _extends2.default)({}, store.state.expansion, {
-        expandedItems
-      }));
-    }
-  }, [store, params.expandedItems]);
-  return {
-    publicAPI: {
-      setItemExpansion,
-      isItemExpanded
-    },
-    instance: {
-      setItemExpansion,
-      applyItemExpansion,
-      expandAllSiblings,
-      resetItemExpansion
-    }
-  };
-};
-exports.useTreeViewExpansion = useTreeViewExpansion;
-const DEFAULT_EXPANDED_ITEMS = [];
-useTreeViewExpansion.applyDefaultValuesToParams = ({
-  params
-}) => (0, _extends2.default)({}, params, {
-  defaultExpandedItems: params.defaultExpandedItems ?? DEFAULT_EXPANDED_ITEMS
-});
-useTreeViewExpansion.getInitialState = params => ({
-  expansion: {
-    expandedItems: params.expandedItems === undefined ? params.defaultExpandedItems : params.expandedItems,
-    expansionTrigger: (0, _useTreeViewExpansion2.getExpansionTrigger)(params)
-  }
-});
-useTreeViewExpansion.params = {
-  expandedItems: true,
-  defaultExpandedItems: true,
-  onExpandedItemsChange: true,
-  onItemExpansionToggle: true,
-  expansionTrigger: true
-};

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

@@ -1,28 +0,0 @@
-import { TreeViewState } from "../../models/index.js";
-import { UseTreeViewExpansionSignature } from "./useTreeViewExpansion.types.js";
-export declare const expansionSelectors: {
-  /**
-   * Gets the expanded items as provided to the component.
-   */
-  expandedItemsRaw: (state: TreeViewState<[UseTreeViewExpansionSignature]>) => readonly string[];
-  /**
-   * Gets the expanded items as a Map.
-   */
-  expandedItemsMap: (args_0: import("../../corePlugins/useTreeViewId/useTreeViewId.types.js").UseTreeViewIdState & import("./useTreeViewExpansion.types.js").UseTreeViewExpansionState & Partial<{}>) => Map<string, true>;
-  /**
-   * Gets the items to render as a flat list (the descendants of an expanded item are listed as siblings of the item).
-   */
-  flatList: (args_0: import("../../corePlugins/useTreeViewId/useTreeViewId.types.js").UseTreeViewIdState & import("./useTreeViewExpansion.types.js").UseTreeViewExpansionState & Partial<{}>) => string[];
-  /**
-   * Gets the slot that triggers the item's expansion when clicked.
-   */
-  triggerSlot: (state: TreeViewState<[UseTreeViewExpansionSignature]>) => "content" | "iconContainer";
-  /**
-   * Checks whether an item is expanded.
-   */
-  isItemExpanded: (args_0: import("../../corePlugins/useTreeViewId/useTreeViewId.types.js").UseTreeViewIdState & import("./useTreeViewExpansion.types.js").UseTreeViewExpansionState & Partial<{}>, itemId: string) => boolean;
-  /**
-   * Checks whether an item is expandable.
-   */
-  isItemExpandable: (args_0: import("../../corePlugins/useTreeViewId/useTreeViewId.types.js").UseTreeViewIdState & import("../useTreeViewItems/index.js").UseTreeViewItemsState<import("../../../index.js").TreeViewDefaultItemModelProperties> & Partial<{}>, _itemId: string) => boolean;
-};