@mui/x-tree-view 8.0.0-alpha.9 → 8.0.0-beta.1

package/esm/internals/utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking.d.ts

@@ -0,0 +1,7 @@
+import { CleanupTracking, UnsubscribeFn, UnregisterToken } from "./CleanupTracking.js";
+export declare class FinalizationRegistryBasedCleanupTracking implements CleanupTracking {
+  registry: FinalizationRegistry<UnsubscribeFn>;
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/{node → esm}/internals/utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking.js

@@ -1,10 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.FinalizationRegistryBasedCleanupTracking = void 0;
-class FinalizationRegistryBasedCleanupTracking {
+export class FinalizationRegistryBasedCleanupTracking {
   constructor() {
     this.registry = new FinalizationRegistry(unsubscribe => {
       if (typeof unsubscribe === 'function') {
@@ -21,5 +15,4 @@ class FinalizationRegistryBasedCleanupTracking {
 
   // eslint-disable-next-line class-methods-use-this
   reset() {}
-}
-exports.FinalizationRegistryBasedCleanupTracking = FinalizationRegistryBasedCleanupTracking;
+}

package/esm/internals/utils/cleanupTracking/TimerBasedCleanupTracking.d.ts

@@ -0,0 +1,9 @@
+import { CleanupTracking, UnregisterToken, UnsubscribeFn } from "./CleanupTracking.js";
+export declare class TimerBasedCleanupTracking implements CleanupTracking {
+  timeouts?: Map<number, NodeJS.Timeout> | undefined;
+  cleanupTimeout: number;
+  constructor(timeout?: number);
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/{node → esm}/internals/utils/cleanupTracking/TimerBasedCleanupTracking.js

@@ -1,12 +1,6 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TimerBasedCleanupTracking = void 0;
 // If no effect ran after this amount of time, we assume that the render was not committed by React
 const CLEANUP_TIMER_LOOP_MILLIS = 1000;
-class TimerBasedCleanupTracking {
+export class TimerBasedCleanupTracking {
   constructor(timeout = CLEANUP_TIMER_LOOP_MILLIS) {
     this.timeouts = new Map();
     this.cleanupTimeout = CLEANUP_TIMER_LOOP_MILLIS;
@@ -41,5 +35,4 @@ class TimerBasedCleanupTracking {
       this.timeouts = undefined;
     }
   }
-}
-exports.TimerBasedCleanupTracking = TimerBasedCleanupTracking;
+}

package/esm/internals/utils/plugins.d.ts

@@ -0,0 +1,2 @@
+import { TreeViewAnyPluginSignature, TreeViewInstance, TreeViewPlugin } from "../models/index.js";
+export declare const hasPlugin: <TSignature extends TreeViewAnyPluginSignature, TInstance extends TreeViewInstance<[], [TSignature]>>(instance: TInstance, plugin: TreeViewPlugin<TSignature>) => instance is Omit<TInstance, keyof TSignature["instance"]> & TSignature["instance"];

package/esm/internals/utils/plugins.js

@@ -0,0 +1,4 @@
+export const hasPlugin = (instance, plugin) => {
+  const plugins = instance.getAvailablePlugins();
+  return plugins.has(plugin);
+};

package/esm/internals/utils/publishTreeViewEvent.d.ts

@@ -0,0 +1,5 @@
+import { UseTreeViewInstanceEventsInstance } from "../corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types.js";
+import { TreeViewAnyPluginSignature, TreeViewUsedEvents } from "../models/index.js";
+export declare const publishTreeViewEvent: <Instance extends UseTreeViewInstanceEventsInstance & {
+  $$signature: TreeViewAnyPluginSignature;
+}, E extends keyof TreeViewUsedEvents<Instance["$$signature"]>>(instance: Instance, eventName: E, params: TreeViewUsedEvents<Instance["$$signature"]>[E]["params"]) => void;

package/esm/internals/utils/publishTreeViewEvent.js

@@ -0,0 +1,3 @@
+export const publishTreeViewEvent = (instance, eventName, params) => {
+  instance.$$publishEvent(eventName, params);
+};

package/esm/internals/utils/selectors.d.ts

@@ -0,0 +1,16 @@
+import { CreateSelectorFunction } from 'reselect';
+import { TreeViewAnyPluginSignature, TreeViewState } from "../models/index.js";
+/**
+ * Type of a selector that take the whole tree view state as input and returns a value based on a required plugin.
+ */
+export type TreeViewRootSelector<TSignature extends TreeViewAnyPluginSignature, IsOptional extends boolean = false> = <TSignatures extends [TSignature]>(state: TreeViewState<TSignatures>) => IsOptional extends true ? TSignature['state'][keyof TSignature['state']] | undefined : TSignature['state'][keyof TSignature['state']];
+/**
+ * Type of a selector that take the whole tree view state as input and returns a value based on an optional plugin.
+ */
+export type TreeViewRootSelectorForOptionalPlugin<TSignature extends TreeViewAnyPluginSignature> = <TSignatures extends [], TOptionalSignatures extends [TSignature]>(state: TreeViewState<TSignatures, TOptionalSignatures>) => TSignature['state'][keyof TSignature['state']] | undefined;
+export type TreeViewSelector<TState, TArgs, TResult> = (state: TState, args: TArgs) => TResult;
+/**
+ * Method wrapping reselect's createSelector to provide caching for tree view instances.
+ *
+ */
+export declare const createSelector: CreateSelectorFunction;

package/{node → esm}/internals/utils/selectors.js

@@ -1,23 +1,26 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createSelector = void 0;
-var _reselect = require("reselect");
-const reselectCreateSelector = (0, _reselect.createSelectorCreator)({
-  memoize: _reselect.lruMemoize,
+import { lruMemoize, createSelectorCreator } from 'reselect';
+const reselectCreateSelector = createSelectorCreator({
+  memoize: lruMemoize,
   memoizeOptions: {
     maxSize: 1,
     equalityCheck: Object.is
   }
 });
 const cache = new WeakMap();
+
+/**
+ * Type of a selector that take the whole tree view state as input and returns a value based on a required plugin.
+ */
+
+/**
+ * Type of a selector that take the whole tree view state as input and returns a value based on an optional plugin.
+ */
+
 /**
  * Method wrapping reselect's createSelector to provide caching for tree view instances.
  *
  */
-const createSelector = (...createSelectorArgs) => {
+export const createSelector = (...createSelectorArgs) => {
   const selector = (state, selectorArgs) => {
     const cacheKey = state.cacheKey;
 
@@ -40,5 +43,4 @@ const createSelector = (...createSelectorArgs) => {
     return fn(state, selectorArgs);
   };
   return selector;
-};
-exports.createSelector = createSelector;
+};

package/esm/internals/utils/tree.d.ts

@@ -0,0 +1,32 @@
+import { TreeViewState } from "../models/index.js";
+import type { UseTreeViewExpansionSignature } from '../plugins/useTreeViewExpansion';
+import type { UseTreeViewItemsSignature } from '../plugins/useTreeViewItems';
+export declare const getPreviousNavigableItem: (state: TreeViewState<[UseTreeViewItemsSignature, UseTreeViewExpansionSignature]>, itemId: string) => string | null;
+export declare const getNextNavigableItem: (state: TreeViewState<[UseTreeViewItemsSignature, UseTreeViewExpansionSignature]>, itemId: string) => string | null;
+export declare const getLastNavigableItem: (state: TreeViewState<[UseTreeViewExpansionSignature, UseTreeViewItemsSignature]>) => string;
+export declare const getFirstNavigableItem: (state: TreeViewState<[UseTreeViewExpansionSignature, UseTreeViewItemsSignature]>) => string;
+/**
+ * This is used to determine the start and end of a selection range so
+ * we can get the items between the two border items.
+ *
+ * It finds the items' common ancestor using
+ * a naive implementation of a lowest common ancestor algorithm
+ * (https://en.wikipedia.org/wiki/Lowest_common_ancestor).
+ * Then compares the ancestor's 2 children that are ancestors of itemA and ItemB
+ * so we can compare their indexes to work out which item comes first in a depth first search.
+ * (https://en.wikipedia.org/wiki/Depth-first_search)
+ *
+ * Another way to put it is which item is shallower in a trémaux tree
+ * https://en.wikipedia.org/wiki/Tr%C3%A9maux_tree
+ */
+export declare const findOrderInTremauxTree: (state: TreeViewState<[UseTreeViewExpansionSignature, UseTreeViewItemsSignature]>, itemAId: string, itemBId: string) => string[];
+export declare const getNonDisabledItemsInRange: (state: TreeViewState<[UseTreeViewItemsSignature, UseTreeViewExpansionSignature]>, itemAId: string, itemBId: string) => string[];
+export declare const getAllNavigableItems: (state: TreeViewState<[UseTreeViewItemsSignature, UseTreeViewExpansionSignature]>) => string[];
+/**
+ * Checks if the target is in a descendant of this item.
+ * This can prevent from firing some logic on the ancestors on the interacted item when the event handler is on the root.
+ * @param {HTMLElement} target The target to check
+ * @param {HTMLElement | null} itemRoot The root of the item to check if the event target is in its descendants
+ * @returns {boolean} Whether the target is in a descendant of this item
+ */
+export declare const isTargetInDescendants: (target: HTMLElement, itemRoot: HTMLElement | null) => boolean;

package/{node → esm}/internals/utils/tree.js

@@ -1,15 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isTargetInDescendants = exports.getPreviousNavigableItem = exports.getNonDisabledItemsInRange = exports.getNextNavigableItem = exports.getLastNavigableItem = exports.getFirstNavigableItem = exports.getAllNavigableItems = exports.findOrderInTremauxTree = void 0;
-var _useTreeViewExpansion = require("../plugins/useTreeViewExpansion/useTreeViewExpansion.selectors");
-var _useTreeViewItems = require("../plugins/useTreeViewItems/useTreeViewItems.selectors");
+import { selectorIsItemExpandable, selectorIsItemExpanded } from "../plugins/useTreeViewExpansion/useTreeViewExpansion.selectors.js";
+import { selectorCanItemBeFocused, selectorIsItemDisabled, selectorItemIndex, selectorItemMeta, selectorItemOrderedChildrenIds, selectorItemParentId } from "../plugins/useTreeViewItems/useTreeViewItems.selectors.js";
 const getLastNavigableItemInArray = (state, items) => {
   // Equivalent to Array.prototype.findLastIndex
   let itemIndex = items.length - 1;
-  while (itemIndex >= 0 && !(0, _useTreeViewItems.selectorCanItemBeFocused)(state, items[itemIndex])) {
+  while (itemIndex >= 0 && !selectorCanItemBeFocused(state, items[itemIndex])) {
     itemIndex -= 1;
   }
   if (itemIndex === -1) {
@@ -17,13 +11,13 @@ const getLastNavigableItemInArray = (state, items) => {
   }
   return items[itemIndex];
 };
-const getPreviousNavigableItem = (state, itemId) => {
-  const itemMeta = (0, _useTreeViewItems.selectorItemMeta)(state, itemId);
+export const getPreviousNavigableItem = (state, itemId) => {
+  const itemMeta = selectorItemMeta(state, itemId);
   if (!itemMeta) {
     return null;
   }
-  const siblings = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, itemMeta.parentId);
-  const itemIndex = (0, _useTreeViewItems.selectorItemIndex)(state, itemId);
+  const siblings = selectorItemOrderedChildrenIds(state, itemMeta.parentId);
+  const itemIndex = selectorItemIndex(state, itemId);
 
   // TODO: What should we do if the parent is not navigable?
   if (itemIndex === 0) {
@@ -32,7 +26,7 @@ const getPreviousNavigableItem = (state, itemId) => {
 
   // Finds the previous navigable sibling.
   let previousNavigableSiblingIndex = itemIndex - 1;
-  while (!(0, _useTreeViewItems.selectorCanItemBeFocused)(state, siblings[previousNavigableSiblingIndex]) && previousNavigableSiblingIndex >= 0) {
+  while (!selectorCanItemBeFocused(state, siblings[previousNavigableSiblingIndex]) && previousNavigableSiblingIndex >= 0) {
     previousNavigableSiblingIndex -= 1;
   }
   if (previousNavigableSiblingIndex === -1) {
@@ -47,47 +41,45 @@ const getPreviousNavigableItem = (state, itemId) => {
 
   // Finds the last navigable ancestor of the previous navigable sibling.
   let currentItemId = siblings[previousNavigableSiblingIndex];
-  let lastNavigableChild = getLastNavigableItemInArray(state, (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, currentItemId));
-  while ((0, _useTreeViewExpansion.selectorIsItemExpanded)(state, currentItemId) && lastNavigableChild != null) {
+  let lastNavigableChild = getLastNavigableItemInArray(state, selectorItemOrderedChildrenIds(state, currentItemId));
+  while (selectorIsItemExpanded(state, currentItemId) && lastNavigableChild != null) {
     currentItemId = lastNavigableChild;
-    lastNavigableChild = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, currentItemId).find(childId => (0, _useTreeViewItems.selectorCanItemBeFocused)(state, childId));
+    lastNavigableChild = selectorItemOrderedChildrenIds(state, currentItemId).find(childId => selectorCanItemBeFocused(state, childId));
   }
   return currentItemId;
 };
-exports.getPreviousNavigableItem = getPreviousNavigableItem;
-const getNextNavigableItem = (state, itemId) => {
+export const getNextNavigableItem = (state, itemId) => {
   // If the item is expanded and has some navigable children, return the first of them.
-  if ((0, _useTreeViewExpansion.selectorIsItemExpanded)(state, itemId)) {
-    const firstNavigableChild = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, itemId).find(childId => (0, _useTreeViewItems.selectorCanItemBeFocused)(state, childId));
+  if (selectorIsItemExpanded(state, itemId)) {
+    const firstNavigableChild = selectorItemOrderedChildrenIds(state, itemId).find(childId => selectorCanItemBeFocused(state, childId));
     if (firstNavigableChild != null) {
       return firstNavigableChild;
     }
   }
-  let itemMeta = (0, _useTreeViewItems.selectorItemMeta)(state, itemId);
+  let itemMeta = selectorItemMeta(state, itemId);
   while (itemMeta != null) {
     // Try to find the first navigable sibling after the current item.
-    const siblings = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, itemMeta.parentId);
-    const currentItemIndex = (0, _useTreeViewItems.selectorItemIndex)(state, itemMeta.id);
+    const siblings = selectorItemOrderedChildrenIds(state, itemMeta.parentId);
+    const currentItemIndex = selectorItemIndex(state, itemMeta.id);
     if (currentItemIndex < siblings.length - 1) {
       let nextItemIndex = currentItemIndex + 1;
-      while (!(0, _useTreeViewItems.selectorCanItemBeFocused)(state, siblings[nextItemIndex]) && nextItemIndex < siblings.length - 1) {
+      while (!selectorCanItemBeFocused(state, siblings[nextItemIndex]) && nextItemIndex < siblings.length - 1) {
         nextItemIndex += 1;
       }
-      if ((0, _useTreeViewItems.selectorCanItemBeFocused)(state, siblings[nextItemIndex])) {
+      if (selectorCanItemBeFocused(state, siblings[nextItemIndex])) {
         return siblings[nextItemIndex];
       }
     }
 
     // If the sibling does not exist, go up a level to the parent and try again.
-    itemMeta = (0, _useTreeViewItems.selectorItemMeta)(state, itemMeta.parentId);
+    itemMeta = selectorItemMeta(state, itemMeta.parentId);
   }
   return null;
 };
-exports.getNextNavigableItem = getNextNavigableItem;
-const getLastNavigableItem = state => {
+export const getLastNavigableItem = state => {
   let itemId = null;
-  while (itemId == null || (0, _useTreeViewExpansion.selectorIsItemExpanded)(state, itemId)) {
-    const children = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, itemId);
+  while (itemId == null || selectorIsItemExpanded(state, itemId)) {
+    const children = selectorItemOrderedChildrenIds(state, itemId);
     const lastNavigableChild = getLastNavigableItemInArray(state, children);
 
     // The item has no navigable children.
@@ -98,8 +90,7 @@ const getLastNavigableItem = state => {
   }
   return itemId;
 };
-exports.getLastNavigableItem = getLastNavigableItem;
-const getFirstNavigableItem = state => (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, null).find(itemId => (0, _useTreeViewItems.selectorCanItemBeFocused)(state, itemId));
+export const getFirstNavigableItem = state => selectorItemOrderedChildrenIds(state, null).find(itemId => selectorCanItemBeFocused(state, itemId));
 
 /**
  * This is used to determine the start and end of a selection range so
@@ -115,13 +106,12 @@ const getFirstNavigableItem = state => (0, _useTreeViewItems.selectorItemOrdered
  * Another way to put it is which item is shallower in a trémaux tree
  * https://en.wikipedia.org/wiki/Tr%C3%A9maux_tree
  */
-exports.getFirstNavigableItem = getFirstNavigableItem;
-const findOrderInTremauxTree = (state, itemAId, itemBId) => {
+export const findOrderInTremauxTree = (state, itemAId, itemBId) => {
   if (itemAId === itemBId) {
     return [itemAId, itemBId];
   }
-  const itemMetaA = (0, _useTreeViewItems.selectorItemMeta)(state, itemAId);
-  const itemMetaB = (0, _useTreeViewItems.selectorItemMeta)(state, itemBId);
+  const itemMetaA = selectorItemMeta(state, itemAId);
+  const itemMetaB = selectorItemMeta(state, itemBId);
   if (!itemMetaA || !itemMetaB) {
     return [itemAId, itemBId];
   }
@@ -142,7 +132,7 @@ const findOrderInTremauxTree = (state, itemAId, itemBId) => {
       aAncestorIsCommon = bFamily.indexOf(aAncestor) !== -1;
       continueA = aAncestor !== null;
       if (!aAncestorIsCommon && continueA) {
-        aAncestor = (0, _useTreeViewItems.selectorItemParentId)(state, aAncestor);
+        aAncestor = selectorItemParentId(state, aAncestor);
       }
     }
     if (continueB && !aAncestorIsCommon) {
@@ -150,34 +140,33 @@ const findOrderInTremauxTree = (state, itemAId, itemBId) => {
       bAncestorIsCommon = aFamily.indexOf(bAncestor) !== -1;
       continueB = bAncestor !== null;
       if (!bAncestorIsCommon && continueB) {
-        bAncestor = (0, _useTreeViewItems.selectorItemParentId)(state, bAncestor);
+        bAncestor = selectorItemParentId(state, bAncestor);
       }
     }
   }
   const commonAncestor = aAncestorIsCommon ? aAncestor : bAncestor;
-  const ancestorFamily = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, commonAncestor);
+  const ancestorFamily = selectorItemOrderedChildrenIds(state, commonAncestor);
   const aSide = aFamily[aFamily.indexOf(commonAncestor) - 1];
   const bSide = bFamily[bFamily.indexOf(commonAncestor) - 1];
   return ancestorFamily.indexOf(aSide) < ancestorFamily.indexOf(bSide) ? [itemAId, itemBId] : [itemBId, itemAId];
 };
-exports.findOrderInTremauxTree = findOrderInTremauxTree;
-const getNonDisabledItemsInRange = (state, itemAId, itemBId) => {
+export const getNonDisabledItemsInRange = (state, itemAId, itemBId) => {
   const getNextItem = itemId => {
     // If the item is expanded and has some children, return the first of them.
-    if ((0, _useTreeViewExpansion.selectorIsItemExpandable)(state, itemId) && (0, _useTreeViewExpansion.selectorIsItemExpanded)(state, itemId)) {
-      return (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, itemId)[0];
+    if (selectorIsItemExpandable(state, itemId) && selectorIsItemExpanded(state, itemId)) {
+      return selectorItemOrderedChildrenIds(state, itemId)[0];
     }
-    let itemMeta = (0, _useTreeViewItems.selectorItemMeta)(state, itemId);
+    let itemMeta = selectorItemMeta(state, itemId);
     while (itemMeta != null) {
       // Try to find the first navigable sibling after the current item.
-      const siblings = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, itemMeta.parentId);
-      const currentItemIndex = (0, _useTreeViewItems.selectorItemIndex)(state, itemMeta.id);
+      const siblings = selectorItemOrderedChildrenIds(state, itemMeta.parentId);
+      const currentItemIndex = selectorItemIndex(state, itemMeta.id);
       if (currentItemIndex < siblings.length - 1) {
         return siblings[currentItemIndex + 1];
       }
 
       // If the item is the last of its siblings, go up a level to the parent and try again.
-      itemMeta = itemMeta.parentId ? (0, _useTreeViewItems.selectorItemMeta)(state, itemMeta.parentId) : null;
+      itemMeta = itemMeta.parentId ? selectorItemMeta(state, itemMeta.parentId) : null;
     }
     throw new Error('Invalid range');
   };
@@ -186,14 +175,13 @@ const getNonDisabledItemsInRange = (state, itemAId, itemBId) => {
   let current = first;
   while (current !== last) {
     current = getNextItem(current);
-    if (!(0, _useTreeViewItems.selectorIsItemDisabled)(state, current)) {
+    if (!selectorIsItemDisabled(state, current)) {
       items.push(current);
     }
   }
   return items;
 };
-exports.getNonDisabledItemsInRange = getNonDisabledItemsInRange;
-const getAllNavigableItems = state => {
+export const getAllNavigableItems = state => {
   let item = getFirstNavigableItem(state);
   const navigableItems = [];
   while (item != null) {
@@ -210,8 +198,6 @@ const getAllNavigableItems = state => {
  * @param {HTMLElement | null} itemRoot The root of the item to check if the event target is in its descendants
  * @returns {boolean} Whether the target is in a descendant of this item
  */
-exports.getAllNavigableItems = getAllNavigableItems;
-const isTargetInDescendants = (target, itemRoot) => {
+export const isTargetInDescendants = (target, itemRoot) => {
   return itemRoot !== target.closest('*[role="treeitem"]');
-};
-exports.isTargetInDescendants = isTargetInDescendants;
+};

package/esm/internals/utils/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getActiveElement: (root?: Document | ShadowRoot) => Element | null;
+export declare function escapeOperandAttributeSelector(operand: string): string;

package/{node → esm}/internals/utils/utils.js

@@ -1,12 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.escapeOperandAttributeSelector = escapeOperandAttributeSelector;
-exports.getActiveElement = void 0;
 // https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
-const getActiveElement = (root = document) => {
+export const getActiveElement = (root = document) => {
   const activeEl = root.activeElement;
   if (!activeEl) {
     return null;
@@ -19,7 +12,6 @@ const getActiveElement = (root = document) => {
 
 // TODO, eventually replaces this function with CSS.escape, once available in jsdom, either added manually or built in
 // https://github.com/jsdom/jsdom/issues/1550#issuecomment-236734471
-exports.getActiveElement = getActiveElement;
-function escapeOperandAttributeSelector(operand) {
+export function escapeOperandAttributeSelector(operand) {
   return operand.replace(/["\\]/g, '\\$&');
 }

package/esm/internals/zero-styled/index.d.ts

@@ -0,0 +1,3 @@
+import { useThemeProps } from '@mui/material/styles';
+export { styled } from '@mui/material/styles';
+export declare function createUseThemeProps(name: string): typeof useThemeProps;

package/esm/internals/zero-styled/index.js

@@ -0,0 +1,7 @@
+import { useThemeProps } from '@mui/material/styles';
+export { styled } from '@mui/material/styles';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function createUseThemeProps(name) {
+  return useThemeProps;
+}

package/esm/models/events.d.ts

@@ -0,0 +1,4 @@
+export type TreeViewCancellableEvent = {
+  defaultMuiPrevented?: boolean;
+};
+export type TreeViewCancellableEventHandler<Event> = (event: Event & TreeViewCancellableEvent) => void;

package/esm/models/events.js

@@ -0,0 +1 @@
+export {};

package/esm/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./items.js";
+export * from "./events.js";
+export type { PropsFromSlot } from '@mui/x-internals/slots';

package/esm/models/index.js

@@ -0,0 +1,5 @@
+export * from "./items.js";
+export * from "./events.js";
+
+// Utils shared across the X packages
+export {};

package/esm/models/items.d.ts

@@ -0,0 +1,13 @@
+export type TreeViewItemId = string;
+export type TreeViewDefaultItemModelProperties = {
+  id: string;
+  label: string;
+};
+export type TreeViewBaseItem<R extends {} = TreeViewDefaultItemModelProperties> = R & {
+  children?: TreeViewBaseItem<R>[];
+};
+export type TreeViewItemsReorderingAction = 'reorder-above' | 'reorder-below' | 'make-child' | 'move-to-parent';
+export interface TreeViewSelectionPropagation {
+  descendants?: boolean;
+  parents?: boolean;
+}

package/esm/models/items.js

@@ -0,0 +1 @@
+export {};

package/esm/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/esm/themeAugmentation/components.d.ts

@@ -0,0 +1,21 @@
+import { ComponentsProps, ComponentsOverrides, ComponentsVariants } from '@mui/material/styles';
+export interface TreeViewComponents<Theme = unknown> {
+  MuiSimpleTreeView?: {
+    defaultProps?: ComponentsProps['MuiSimpleTreeView'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiSimpleTreeView'];
+    variants?: ComponentsVariants<Theme>['MuiSimpleTreeView'];
+  };
+  MuiRichTreeView?: {
+    defaultProps?: ComponentsProps['MuiRichTreeView'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiRichTreeView'];
+    variants?: ComponentsVariants<Theme>['MuiRichTreeView'];
+  };
+  MuiTreeItem?: {
+    defaultProps?: ComponentsProps['MuiTreeItem'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiTreeItem'];
+    variants?: ComponentsVariants<Theme>['MuiTreeItem'];
+  };
+}
+declare module '@mui/material/styles' {
+  interface Components<Theme = unknown> extends TreeViewComponents<Theme> {}
+}

package/esm/themeAugmentation/index.d.ts

@@ -0,0 +1,3 @@
+export type * from './overrides';
+export type * from './props';
+export type * from './components';

package/esm/themeAugmentation/overrides.d.ts

@@ -0,0 +1,16 @@
+import { RichTreeViewClassKey } from "../RichTreeView/index.js";
+import { SimpleTreeViewClassKey } from "../SimpleTreeView/index.js";
+import { TreeItemClassKey } from "../TreeItem/index.js";
+
+// prettier-ignore
+export interface TreeViewComponentNameToClassKey {
+  MuiSimpleTreeView: SimpleTreeViewClassKey;
+  MuiRichTreeView: RichTreeViewClassKey;
+  MuiTreeItem: TreeItemClassKey;
+}
+declare module '@mui/material/styles' {
+  interface ComponentNameToClassKey extends TreeViewComponentNameToClassKey {}
+}
+
+// disable automatic export
+export {};

package/esm/themeAugmentation/props.d.ts

@@ -0,0 +1,14 @@
+import { SimpleTreeViewProps } from "../SimpleTreeView/index.js";
+import { RichTreeViewProps } from "../RichTreeView/index.js";
+import { TreeItemProps } from "../TreeItem/index.js";
+export interface TreeViewComponentsPropsList {
+  MuiSimpleTreeView: SimpleTreeViewProps<any>;
+  MuiRichTreeView: RichTreeViewProps<any, any>;
+  MuiTreeItem: TreeItemProps;
+}
+declare module '@mui/material/styles' {
+  interface ComponentsPropsList extends TreeViewComponentsPropsList {}
+}
+
+// disable automatic export
+export {};

package/esm/useTreeItem/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeItem } from "./useTreeItem.js";
+export type { UseTreeItemParameters, UseTreeItemReturnValue, UseTreeItemStatus, UseTreeItemRootSlotOwnProps, UseTreeItemContentSlotOwnProps, UseTreeItemLabelInputSlotOwnProps, UseTreeItemLabelSlotOwnProps, UseTreeItemCheckboxSlotOwnProps, UseTreeItemIconContainerSlotOwnProps, UseTreeItemGroupTransitionSlotOwnProps, UseTreeItemDragAndDropOverlaySlotOwnProps } from './useTreeItem.types';

package/esm/useTreeItem/index.js

@@ -0,0 +1 @@
+export { useTreeItem } from "./useTreeItem.js";

package/esm/useTreeItem/useTreeItem.d.ts

@@ -0,0 +1,2 @@
+import { UseTreeItemParameters, UseTreeItemReturnValue, UseTreeItemMinimalPlugins, UseTreeItemOptionalPlugins } from "./useTreeItem.types.js";
+export declare const useTreeItem: <TSignatures extends UseTreeItemMinimalPlugins = UseTreeItemMinimalPlugins, TOptionalSignatures extends UseTreeItemOptionalPlugins = UseTreeItemOptionalPlugins>(parameters: UseTreeItemParameters) => UseTreeItemReturnValue<TSignatures, TOptionalSignatures>;