@mui/x-tree-view 8.23.0 → 8.24.0

package/internals/hooks/useTreeViewRootProps.d.ts

@@ -0,0 +1,287 @@
+import * as React from 'react';
+import { EventHandlers } from '@mui/utils/types';
+import { TreeViewCancellableEvent } from "../../models/index.js";
+import { TreeViewAnyStore } from "../models/index.js";
+export declare function useTreeViewRootProps<TStore extends TreeViewAnyStore>(store: TStore, forwardedProps: React.HTMLAttributes<HTMLUListElement>, ref: React.Ref<HTMLUListElement | null> | undefined): (otherHandlers: EventHandlers) => {
+  style: React.CSSProperties;
+  onFocus: (event: React.FocusEvent<HTMLUListElement> & TreeViewCancellableEvent) => void;
+  onBlur: (event: React.FocusEvent<HTMLUListElement> & TreeViewCancellableEvent) => void;
+  defaultChecked?: boolean | undefined;
+  defaultValue?: string | number | readonly string[] | undefined;
+  suppressContentEditableWarning?: boolean | undefined;
+  suppressHydrationWarning?: boolean | undefined;
+  accessKey?: string | undefined;
+  autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+  autoFocus?: boolean | undefined;
+  className?: string | undefined;
+  contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+  contextMenu?: string | undefined;
+  dir?: string | undefined;
+  draggable?: (boolean | "true" | "false") | undefined;
+  enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+  hidden?: boolean | undefined;
+  id: string | undefined;
+  lang?: string | undefined;
+  nonce?: string | undefined;
+  slot?: string | undefined;
+  spellCheck?: (boolean | "true" | "false") | undefined;
+  tabIndex?: number | undefined;
+  title?: string | undefined;
+  translate?: "yes" | "no" | undefined;
+  radioGroup?: string | undefined;
+  role: string;
+  about?: string | undefined;
+  content?: string | undefined;
+  datatype?: string | undefined;
+  inlist?: any;
+  prefix?: string | undefined;
+  property?: string | undefined;
+  rel?: string | undefined;
+  resource?: string | undefined;
+  rev?: string | undefined;
+  typeof?: string | undefined;
+  vocab?: string | undefined;
+  autoCorrect?: string | undefined;
+  autoSave?: string | undefined;
+  color?: string | undefined;
+  itemProp?: string | undefined;
+  itemScope?: boolean | undefined;
+  itemType?: string | undefined;
+  itemID?: string | undefined;
+  itemRef?: string | undefined;
+  results?: number | undefined;
+  security?: string | undefined;
+  unselectable?: "on" | "off" | undefined;
+  popover?: "" | "auto" | "manual" | "hint" | undefined;
+  popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+  popoverTarget?: string | undefined;
+  inert?: boolean | undefined;
+  inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+  is?: string | undefined;
+  exportparts?: string | undefined;
+  part?: string | undefined;
+  "aria-activedescendant"?: string | undefined;
+  "aria-atomic"?: (boolean | "true" | "false") | undefined;
+  "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+  "aria-braillelabel"?: string | undefined;
+  "aria-brailleroledescription"?: string | undefined;
+  "aria-busy"?: (boolean | "true" | "false") | undefined;
+  "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+  "aria-colcount"?: number | undefined;
+  "aria-colindex"?: number | undefined;
+  "aria-colindextext"?: string | undefined;
+  "aria-colspan"?: number | undefined;
+  "aria-controls"?: string | undefined;
+  "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+  "aria-describedby"?: string | undefined;
+  "aria-description"?: string | undefined;
+  "aria-details"?: string | undefined;
+  "aria-disabled"?: (boolean | "true" | "false") | undefined;
+  "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+  "aria-errormessage"?: string | undefined;
+  "aria-expanded"?: (boolean | "true" | "false") | undefined;
+  "aria-flowto"?: string | undefined;
+  "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+  "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+  "aria-hidden"?: (boolean | "true" | "false") | undefined;
+  "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+  "aria-keyshortcuts"?: string | undefined;
+  "aria-label"?: string | undefined;
+  "aria-labelledby"?: string | undefined;
+  "aria-level"?: number | undefined;
+  "aria-live"?: "off" | "assertive" | "polite" | undefined;
+  "aria-modal"?: (boolean | "true" | "false") | undefined;
+  "aria-multiline"?: (boolean | "true" | "false") | undefined;
+  "aria-multiselectable": boolean | "true" | "false";
+  "aria-orientation"?: "horizontal" | "vertical" | undefined;
+  "aria-owns"?: string | undefined;
+  "aria-placeholder"?: string | undefined;
+  "aria-posinset"?: number | undefined;
+  "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+  "aria-readonly"?: (boolean | "true" | "false") | undefined;
+  "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+  "aria-required"?: (boolean | "true" | "false") | undefined;
+  "aria-roledescription"?: string | undefined;
+  "aria-rowcount"?: number | undefined;
+  "aria-rowindex"?: number | undefined;
+  "aria-rowindextext"?: string | undefined;
+  "aria-rowspan"?: number | undefined;
+  "aria-selected"?: (boolean | "true" | "false") | undefined;
+  "aria-setsize"?: number | undefined;
+  "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+  "aria-valuemax"?: number | undefined;
+  "aria-valuemin"?: number | undefined;
+  "aria-valuenow"?: number | undefined;
+  "aria-valuetext"?: string | undefined;
+  children?: React.ReactNode | undefined;
+  dangerouslySetInnerHTML?: {
+    __html: string | TrustedHTML;
+  } | undefined;
+  onCopy?: React.ClipboardEventHandler<HTMLUListElement> | undefined;
+  onCopyCapture?: React.ClipboardEventHandler<HTMLUListElement> | undefined;
+  onCut?: React.ClipboardEventHandler<HTMLUListElement> | undefined;
+  onCutCapture?: React.ClipboardEventHandler<HTMLUListElement> | undefined;
+  onPaste?: React.ClipboardEventHandler<HTMLUListElement> | undefined;
+  onPasteCapture?: React.ClipboardEventHandler<HTMLUListElement> | undefined;
+  onCompositionEnd?: React.CompositionEventHandler<HTMLUListElement> | undefined;
+  onCompositionEndCapture?: React.CompositionEventHandler<HTMLUListElement> | undefined;
+  onCompositionStart?: React.CompositionEventHandler<HTMLUListElement> | undefined;
+  onCompositionStartCapture?: React.CompositionEventHandler<HTMLUListElement> | undefined;
+  onCompositionUpdate?: React.CompositionEventHandler<HTMLUListElement> | undefined;
+  onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLUListElement> | undefined;
+  onFocusCapture?: React.FocusEventHandler<HTMLUListElement> | undefined;
+  onBlurCapture?: React.FocusEventHandler<HTMLUListElement> | undefined;
+  onChange?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onChangeCapture?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onBeforeInput?: React.InputEventHandler<HTMLUListElement> | undefined;
+  onBeforeInputCapture?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onInput?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onInputCapture?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onReset?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onResetCapture?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onSubmit?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onSubmitCapture?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onInvalid?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onInvalidCapture?: React.FormEventHandler<HTMLUListElement> | undefined;
+  onLoad?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onLoadCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onError?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onErrorCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onKeyDown?: React.KeyboardEventHandler<HTMLUListElement> | undefined;
+  onKeyDownCapture?: React.KeyboardEventHandler<HTMLUListElement> | undefined;
+  onKeyPress?: React.KeyboardEventHandler<HTMLUListElement> | undefined;
+  onKeyPressCapture?: React.KeyboardEventHandler<HTMLUListElement> | undefined;
+  onKeyUp?: React.KeyboardEventHandler<HTMLUListElement> | undefined;
+  onKeyUpCapture?: React.KeyboardEventHandler<HTMLUListElement> | undefined;
+  onAbort?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onAbortCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onCanPlay?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onCanPlayCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onCanPlayThrough?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onCanPlayThroughCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onDurationChange?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onDurationChangeCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onEmptied?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onEmptiedCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onEncrypted?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onEncryptedCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onEnded?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onEndedCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onLoadedData?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onLoadedDataCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onLoadedMetadata?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onLoadedMetadataCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onLoadStart?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onLoadStartCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onPause?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onPauseCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onPlay?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onPlayCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onPlaying?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onPlayingCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onProgress?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onProgressCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onRateChange?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onRateChangeCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onSeeked?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onSeekedCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onSeeking?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onSeekingCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onStalled?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onStalledCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onSuspend?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onSuspendCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onTimeUpdate?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onTimeUpdateCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onVolumeChange?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onVolumeChangeCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onWaiting?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onWaitingCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onAuxClick?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onAuxClickCapture?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onClick?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onClickCapture?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onContextMenu?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onContextMenuCapture?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onDoubleClick?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onDoubleClickCapture?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onDrag?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragCapture?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragEnd?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragEndCapture?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragEnter?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragEnterCapture?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragExit?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragExitCapture?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragLeave?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragLeaveCapture?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragOver?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragOverCapture?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragStart?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDragStartCapture?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDrop?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onDropCapture?: React.DragEventHandler<HTMLUListElement> | undefined;
+  onMouseDown?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseDownCapture?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseEnter?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseLeave?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseMove?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseMoveCapture?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseOut?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseOutCapture?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseOver?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseOverCapture?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseUp?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onMouseUpCapture?: React.MouseEventHandler<HTMLUListElement> | undefined;
+  onSelect?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onSelectCapture?: React.ReactEventHandler<HTMLUListElement> | undefined;
+  onTouchCancel?: React.TouchEventHandler<HTMLUListElement> | undefined;
+  onTouchCancelCapture?: React.TouchEventHandler<HTMLUListElement> | undefined;
+  onTouchEnd?: React.TouchEventHandler<HTMLUListElement> | undefined;
+  onTouchEndCapture?: React.TouchEventHandler<HTMLUListElement> | undefined;
+  onTouchMove?: React.TouchEventHandler<HTMLUListElement> | undefined;
+  onTouchMoveCapture?: React.TouchEventHandler<HTMLUListElement> | undefined;
+  onTouchStart?: React.TouchEventHandler<HTMLUListElement> | undefined;
+  onTouchStartCapture?: React.TouchEventHandler<HTMLUListElement> | undefined;
+  onPointerDown?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerDownCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerMove?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerMoveCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerUp?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerUpCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerCancel?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerCancelCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerEnter?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerLeave?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerOver?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerOverCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerOut?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onPointerOutCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onGotPointerCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onLostPointerCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLUListElement> | undefined;
+  onScroll?: React.UIEventHandler<HTMLUListElement> | undefined;
+  onScrollCapture?: React.UIEventHandler<HTMLUListElement> | undefined;
+  onScrollEnd?: React.UIEventHandler<HTMLUListElement> | undefined;
+  onScrollEndCapture?: React.UIEventHandler<HTMLUListElement> | undefined;
+  onWheel?: React.WheelEventHandler<HTMLUListElement> | undefined;
+  onWheelCapture?: React.WheelEventHandler<HTMLUListElement> | undefined;
+  onAnimationStart?: React.AnimationEventHandler<HTMLUListElement> | undefined;
+  onAnimationStartCapture?: React.AnimationEventHandler<HTMLUListElement> | undefined;
+  onAnimationEnd?: React.AnimationEventHandler<HTMLUListElement> | undefined;
+  onAnimationEndCapture?: React.AnimationEventHandler<HTMLUListElement> | undefined;
+  onAnimationIteration?: React.AnimationEventHandler<HTMLUListElement> | undefined;
+  onAnimationIterationCapture?: React.AnimationEventHandler<HTMLUListElement> | undefined;
+  onToggle?: React.ToggleEventHandler<HTMLUListElement> | undefined;
+  onBeforeToggle?: React.ToggleEventHandler<HTMLUListElement> | undefined;
+  onTransitionCancel?: React.TransitionEventHandler<HTMLUListElement> | undefined;
+  onTransitionCancelCapture?: React.TransitionEventHandler<HTMLUListElement> | undefined;
+  onTransitionEnd?: React.TransitionEventHandler<HTMLUListElement> | undefined;
+  onTransitionEndCapture?: React.TransitionEventHandler<HTMLUListElement> | undefined;
+  onTransitionRun?: React.TransitionEventHandler<HTMLUListElement> | undefined;
+  onTransitionRunCapture?: React.TransitionEventHandler<HTMLUListElement> | undefined;
+  onTransitionStart?: React.TransitionEventHandler<HTMLUListElement> | undefined;
+  onTransitionStartCapture?: React.TransitionEventHandler<HTMLUListElement> | undefined;
+  ref: React.Ref<HTMLUListElement | null> | undefined;
+};

package/internals/hooks/useTreeViewRootProps.js

@@ -0,0 +1,36 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewRootProps = useTreeViewRootProps;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _store = require("@mui/x-internals/store");
+var _id = require("../plugins/id");
+var _selection = require("../plugins/selection");
+var _items = require("../plugins/items");
+function useTreeViewRootProps(store, forwardedProps, ref) {
+  const treeId = (0, _store.useStore)(store, _id.idSelectors.treeId);
+  const itemChildrenIndentation = (0, _store.useStore)(store, _items.itemsSelectors.itemChildrenIndentation);
+  const isMultiSelectEnabled = (0, _store.useStore)(store, _selection.selectionSelectors.isMultiSelectEnabled);
+  return otherHandlers => (0, _extends2.default)({
+    ref,
+    role: 'tree',
+    id: treeId,
+    'aria-multiselectable': isMultiSelectEnabled
+  }, forwardedProps, otherHandlers, {
+    style: (0, _extends2.default)({}, forwardedProps.style, {
+      '--TreeView-itemChildrenIndentation': typeof itemChildrenIndentation === 'number' ? `${itemChildrenIndentation}px` : itemChildrenIndentation
+    }),
+    onFocus: event => {
+      otherHandlers.onFocus?.(event);
+      store.focus.handleRootFocus(event);
+    },
+    onBlur: event => {
+      otherHandlers.onBlur?.(event);
+      store.focus.handleRootBlur(event);
+    }
+  });
+}

package/internals/hooks/useTreeViewStore.d.ts

@@ -0,0 +1,10 @@
+import { TreeViewAnyStore } from "../models/index.js";
+interface ValidTreeViewStoreConstructor<TStore extends TreeViewAnyStore> {
+  new (parameters: TStore['parameters']): TStore;
+}
+export type UseTreeViewStoreParameters<TStore extends TreeViewAnyStore> = Omit<Parameters<TStore['updateStateFromParameters']>[0], 'isRtl'>;
+/**
+ * Creates a Tree View store and keep it in sync with the provided parameters.
+ */
+export declare function useTreeViewStore<TStore extends TreeViewAnyStore>(StoreClass: ValidTreeViewStoreConstructor<TStore>, parameters: UseTreeViewStoreParameters<TStore>): TStore;
+export {};

package/internals/hooks/useTreeViewStore.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewStore = useTreeViewStore;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _useRefWithInit = require("@base-ui/utils/useRefWithInit");
+var _useIsoLayoutEffect = require("@base-ui/utils/useIsoLayoutEffect");
+var _useOnMount = require("@base-ui/utils/useOnMount");
+var _RtlProvider = require("@mui/system/RtlProvider");
+/**
+ * Creates a Tree View store and keep it in sync with the provided parameters.
+ */
+function useTreeViewStore(StoreClass, parameters) {
+  const isRtl = (0, _RtlProvider.useRtl)();
+  const store = (0, _useRefWithInit.useRefWithInit)(() => new StoreClass((0, _extends2.default)({}, parameters, {
+    isRtl
+  }))).current;
+  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => store.updateStateFromParameters((0, _extends2.default)({}, parameters, {
+    isRtl
+  })), [store, isRtl, parameters]);
+  (0, _useOnMount.useOnMount)(store.disposeEffect);
+  return store;
+}

package/internals/index.d.ts

@@ -1,25 +1,19 @@
-export { useTreeView } from "./useTreeView/index.js";
 export { TreeViewProvider, useTreeViewContext } from "./TreeViewProvider/index.js";
 export { RichTreeViewItems } from "./components/RichTreeViewItems.js";
 export type { RichTreeViewItemsSlots, RichTreeViewItemsSlotProps } from "./components/RichTreeViewItems.js";
-export { unstable_resetCleanupTracking, useInstanceEventHandler } from "./hooks/useInstanceEventHandler.js";
-export type { TreeViewPlugin, TreeViewPluginSignature, ConvertPluginsIntoSignatures, MergeSignaturesProperty, TreeViewPublicAPI, TreeViewState, TreeViewItemMeta, TreeViewInstance, TreeViewItemPlugin, TreeViewUsedStore, TreeViewUsedInstance, TreeViewUsedParamsWithDefaults } from "./models/index.js";
-export type { TreeViewCorePluginParameters } from "./corePlugins/index.js";
-export { useTreeViewExpansion, expansionSelectors } from "./plugins/useTreeViewExpansion/index.js";
-export type { UseTreeViewExpansionSignature, UseTreeViewExpansionParameters } from "./plugins/useTreeViewExpansion/index.js";
-export { useTreeViewSelection, selectionSelectors } from "./plugins/useTreeViewSelection/index.js";
-export type { UseTreeViewSelectionSignature, UseTreeViewSelectionParameters } from "./plugins/useTreeViewSelection/index.js";
-export { useTreeViewFocus } from "./plugins/useTreeViewFocus/index.js";
-export type { UseTreeViewFocusSignature, UseTreeViewFocusParameters } from "./plugins/useTreeViewFocus/index.js";
-export { useTreeViewKeyboardNavigation } from "./plugins/useTreeViewKeyboardNavigation/index.js";
-export type { UseTreeViewKeyboardNavigationSignature } from "./plugins/useTreeViewKeyboardNavigation/index.js";
-export { useTreeViewItems, buildSiblingIndexes, itemsSelectors, TREE_VIEW_ROOT_PARENT_ID } from "./plugins/useTreeViewItems/index.js";
-export type { UseTreeViewItemsSignature, UseTreeViewItemsParameters, UseTreeViewItemsState } from "./plugins/useTreeViewItems/index.js";
-export { useTreeViewLabel, labelSelectors } from "./plugins/useTreeViewLabel/index.js";
-export type { UseTreeViewLabelSignature, UseTreeViewLabelParameters } from "./plugins/useTreeViewLabel/index.js";
-export type { UseTreeViewLazyLoadingSignature, UseTreeViewLazyLoadingParameters, UseTreeViewLazyLoadingInstance, DataSource } from "./plugins/useTreeViewLazyLoading/index.js";
-export { lazyLoadingSelectors } from "./plugins/useTreeViewLazyLoading/index.js";
-export { useTreeViewJSXItems } from "./plugins/useTreeViewJSXItems/index.js";
-export type { UseTreeViewJSXItemsSignature, UseTreeViewJSXItemsParameters } from "./plugins/useTreeViewJSXItems/index.js";
+export { useTreeViewRootProps } from "./hooks/useTreeViewRootProps.js";
+export { useTreeViewStore } from "./hooks/useTreeViewStore.js";
+export type { UseTreeViewStoreParameters } from "./hooks/useTreeViewStore.js";
+export type { TreeViewItemMeta, TreeViewItemPlugin, TreeViewEventParameters, TreeViewEventEvent, TreeViewPublicAPI } from "./models/index.js";
+export { expansionSelectors } from "./plugins/expansion/index.js";
+export { selectionSelectors } from "./plugins/selection/index.js";
+export { buildSiblingIndexes, itemsSelectors, TREE_VIEW_ROOT_PARENT_ID } from "./plugins/items/index.js";
+export { labelSelectors } from "./plugins/labelEditing/index.js";
+export { lazyLoadingSelectors } from "./plugins/lazyLoading/index.js";
 export { isTargetInDescendants } from "./utils/tree.js";
-export type { TreeViewClasses, TreeViewSlots, TreeViewSlotProps } from "./TreeViewProvider/TreeViewStyleContext.js";
+export type { TreeViewClasses, TreeViewSlots, TreeViewSlotProps } from "./TreeViewProvider/TreeViewStyleContext.js";
+export { MinimalTreeViewStore } from "./MinimalTreeViewStore/index.js";
+export type { TreeViewParametersToStateMapper } from "./MinimalTreeViewStore/index.js";
+export { ExtendableRichTreeViewStore } from "./RichTreeViewStore/index.js";
+export type { RichTreeViewState, RichTreeViewStoreParameters } from "./RichTreeViewStore/index.js";
+export { TreeViewItemDepthContext } from "./TreeViewItemDepthContext/index.js";

package/internals/index.js

@@ -3,6 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "ExtendableRichTreeViewStore", {
+  enumerable: true,
+  get: function () {
+    return _RichTreeViewStore.ExtendableRichTreeViewStore;
+  }
+});
+Object.defineProperty(exports, "MinimalTreeViewStore", {
+  enumerable: true,
+  get: function () {
+    return _MinimalTreeViewStore.MinimalTreeViewStore;
+  }
+});
 Object.defineProperty(exports, "RichTreeViewItems", {
   enumerable: true,
   get: function () {
@@ -12,7 +24,13 @@ Object.defineProperty(exports, "RichTreeViewItems", {
 Object.defineProperty(exports, "TREE_VIEW_ROOT_PARENT_ID", {
   enumerable: true,
   get: function () {
-    return _useTreeViewItems.TREE_VIEW_ROOT_PARENT_ID;
+    return _items.TREE_VIEW_ROOT_PARENT_ID;
+  }
+});
+Object.defineProperty(exports, "TreeViewItemDepthContext", {
+  enumerable: true,
+  get: function () {
+    return _TreeViewItemDepthContext.TreeViewItemDepthContext;
   }
 });
 Object.defineProperty(exports, "TreeViewProvider", {
@@ -24,13 +42,13 @@ Object.defineProperty(exports, "TreeViewProvider", {
 Object.defineProperty(exports, "buildSiblingIndexes", {
   enumerable: true,
   get: function () {
-    return _useTreeViewItems.buildSiblingIndexes;
+    return _items.buildSiblingIndexes;
   }
 });
 Object.defineProperty(exports, "expansionSelectors", {
   enumerable: true,
   get: function () {
-    return _useTreeViewExpansion.expansionSelectors;
+    return _expansion.expansionSelectors;
   }
 });
 Object.defineProperty(exports, "isTargetInDescendants", {
@@ -42,43 +60,25 @@ Object.defineProperty(exports, "isTargetInDescendants", {
 Object.defineProperty(exports, "itemsSelectors", {
   enumerable: true,
   get: function () {
-    return _useTreeViewItems.itemsSelectors;
+    return _items.itemsSelectors;
   }
 });
 Object.defineProperty(exports, "labelSelectors", {
   enumerable: true,
   get: function () {
-    return _useTreeViewLabel.labelSelectors;
+    return _labelEditing.labelSelectors;
   }
 });
 Object.defineProperty(exports, "lazyLoadingSelectors", {
   enumerable: true,
   get: function () {
-    return _useTreeViewLazyLoading.lazyLoadingSelectors;
+    return _lazyLoading.lazyLoadingSelectors;
   }
 });
 Object.defineProperty(exports, "selectionSelectors", {
   enumerable: true,
   get: function () {
-    return _useTreeViewSelection.selectionSelectors;
-  }
-});
-Object.defineProperty(exports, "unstable_resetCleanupTracking", {
-  enumerable: true,
-  get: function () {
-    return _useInstanceEventHandler.unstable_resetCleanupTracking;
-  }
-});
-Object.defineProperty(exports, "useInstanceEventHandler", {
-  enumerable: true,
-  get: function () {
-    return _useInstanceEventHandler.useInstanceEventHandler;
-  }
-});
-Object.defineProperty(exports, "useTreeView", {
-  enumerable: true,
-  get: function () {
-    return _useTreeView.useTreeView;
+    return _selection.selectionSelectors;
   }
 });
 Object.defineProperty(exports, "useTreeViewContext", {
@@ -87,58 +87,28 @@ Object.defineProperty(exports, "useTreeViewContext", {
     return _TreeViewProvider.useTreeViewContext;
   }
 });
-Object.defineProperty(exports, "useTreeViewExpansion", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewExpansion.useTreeViewExpansion;
-  }
-});
-Object.defineProperty(exports, "useTreeViewFocus", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewFocus.useTreeViewFocus;
-  }
-});
-Object.defineProperty(exports, "useTreeViewItems", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewItems.useTreeViewItems;
-  }
-});
-Object.defineProperty(exports, "useTreeViewJSXItems", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewJSXItems.useTreeViewJSXItems;
-  }
-});
-Object.defineProperty(exports, "useTreeViewKeyboardNavigation", {
-  enumerable: true,
-  get: function () {
-    return _useTreeViewKeyboardNavigation.useTreeViewKeyboardNavigation;
-  }
-});
-Object.defineProperty(exports, "useTreeViewLabel", {
+Object.defineProperty(exports, "useTreeViewRootProps", {
   enumerable: true,
   get: function () {
-    return _useTreeViewLabel.useTreeViewLabel;
+    return _useTreeViewRootProps.useTreeViewRootProps;
   }
 });
-Object.defineProperty(exports, "useTreeViewSelection", {
+Object.defineProperty(exports, "useTreeViewStore", {
   enumerable: true,
   get: function () {
-    return _useTreeViewSelection.useTreeViewSelection;
+    return _useTreeViewStore.useTreeViewStore;
   }
 });
-var _useTreeView = require("./useTreeView");
 var _TreeViewProvider = require("./TreeViewProvider");
 var _RichTreeViewItems = require("./components/RichTreeViewItems");
-var _useInstanceEventHandler = require("./hooks/useInstanceEventHandler");
-var _useTreeViewExpansion = require("./plugins/useTreeViewExpansion");
-var _useTreeViewSelection = require("./plugins/useTreeViewSelection");
-var _useTreeViewFocus = require("./plugins/useTreeViewFocus");
-var _useTreeViewKeyboardNavigation = require("./plugins/useTreeViewKeyboardNavigation");
-var _useTreeViewItems = require("./plugins/useTreeViewItems");
-var _useTreeViewLabel = require("./plugins/useTreeViewLabel");
-var _useTreeViewLazyLoading = require("./plugins/useTreeViewLazyLoading");
-var _useTreeViewJSXItems = require("./plugins/useTreeViewJSXItems");
-var _tree = require("./utils/tree");
+var _useTreeViewRootProps = require("./hooks/useTreeViewRootProps");
+var _useTreeViewStore = require("./hooks/useTreeViewStore");
+var _expansion = require("./plugins/expansion");
+var _selection = require("./plugins/selection");
+var _items = require("./plugins/items");
+var _labelEditing = require("./plugins/labelEditing");
+var _lazyLoading = require("./plugins/lazyLoading");
+var _tree = require("./utils/tree");
+var _MinimalTreeViewStore = require("./MinimalTreeViewStore");
+var _RichTreeViewStore = require("./RichTreeViewStore");
+var _TreeViewItemDepthContext = require("./TreeViewItemDepthContext");

package/internals/models/events.d.ts

@@ -1,5 +1,26 @@
 import { MuiEvent } from '@mui/x-internals/types';
-export interface TreeViewEventLookupElement {
-  params: object;
+import { TreeViewItemId } from "../../models/index.js";
+interface TreeViewEventLookup {
+  /**
+   * Fired before an item is expanded or collapsed.
+   */
+  beforeItemToggleExpansion: {
+    parameters: {
+      isExpansionPrevented: boolean;
+      shouldBeExpanded: boolean;
+      itemId: TreeViewItemId;
+    };
+    event: React.SyntheticEvent | null;
+  };
 }
-export type TreeViewEventListener<E extends TreeViewEventLookupElement> = (params: E['params'], event: MuiEvent<{}>) => void;
+export type TreeViewEvents = keyof TreeViewEventLookup;
+export type TreeViewEventListener<E extends TreeViewEvents> = (params: TreeViewEventParameters<E>, event: TreeViewEventLookup[E] extends {
+  event: any;
+} ? MuiEvent<TreeViewEventLookup[E]['event']> : MuiEvent<{}>) => void;
+export type TreeViewEventParameters<E extends TreeViewEvents> = TreeViewEventLookup[E] extends {
+  parameters: infer P;
+} ? P : undefined;
+export type TreeViewEventEvent<E extends TreeViewEvents> = TreeViewEventLookup[E] extends {
+  event: infer EV;
+} ? EV : undefined;
+export {};

package/internals/models/index.d.ts

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