@mui/x-tree-view 8.0.0-alpha.11 → 8.0.0-alpha.13

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.types.d.ts

@@ -1,149 +1,144 @@
 import * as React from 'react';
 import type { DefaultizedProps } from '@mui/x-internals/types';
 import type { TreeViewPluginSignature } from '../../models';
-import { UseTreeViewItemsSignature } from '../useTreeViewItems';
-import { UseTreeViewExpansionSignature } from '../useTreeViewExpansion';
-import { TreeViewSelectionPropagation, TreeViewCancellableEventHandler } from '../../../models';
+import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
+import { UseTreeViewExpansionSignature } from "../useTreeViewExpansion/index.js";
+import { TreeViewSelectionPropagation, TreeViewCancellableEventHandler } from "../../../models/index.js";
 export interface UseTreeViewSelectionPublicAPI {
-    /**
-     * Select or deselect an item.
-     * @param {object} params The params of the method.
-     * @param {React.SyntheticEvent} params.event The DOM event that triggered the change.
-     * @param {string} params.itemId The id of the item to select or deselect.
-     * @param {boolean} params.keepExistingSelection If `true`, the other already selected items will remain selected, otherwise, they will be deselected. This parameter is only relevant when `multiSelect` is `true`
-     * @param {boolean | undefined} params.shouldBeSelected If `true` the item will be selected. If `false` the item will be deselected. If not defined, the item's new selection status will be the opposite of its current one.
-     */
-    selectItem: (params: {
-        event: React.SyntheticEvent;
-        itemId: string;
-        keepExistingSelection?: boolean;
-        shouldBeSelected?: boolean;
-    }) => void;
+  /**
+   * Select or deselect an item.
+   * @param {object} params The params of the method.
+   * @param {React.SyntheticEvent} params.event The DOM event that triggered the change.
+   * @param {string} params.itemId The id of the item to select or deselect.
+   * @param {boolean} params.keepExistingSelection If `true`, the other already selected items will remain selected, otherwise, they will be deselected. This parameter is only relevant when `multiSelect` is `true`
+   * @param {boolean | undefined} params.shouldBeSelected If `true` the item will be selected. If `false` the item will be deselected. If not defined, the item's new selection status will be the opposite of its current one.
+   */
+  selectItem: (params: {
+    event: React.SyntheticEvent;
+    itemId: string;
+    keepExistingSelection?: boolean;
+    shouldBeSelected?: boolean;
+  }) => void;
 }
 export interface UseTreeViewSelectionInstance extends UseTreeViewSelectionPublicAPI {
-    /**
-     * Select all the navigable items in the tree.
-     * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-     */
-    selectAllNavigableItems: (event: React.SyntheticEvent) => void;
-    /**
-     * Expand the current selection range up to the given item.
-     * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-     * @param {string} itemId The id of the item to expand the selection to.
-     */
-    expandSelectionRange: (event: React.SyntheticEvent, itemId: string) => void;
-    /**
-     * Expand the current selection range from the first navigable item to the given item.
-     * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-     * @param {string} itemId The id of the item up to which the selection range should be expanded.
-     */
-    selectRangeFromStartToItem: (event: React.SyntheticEvent, itemId: string) => void;
-    /**
-     * Expand the current selection range from the given item to the last navigable item.
-     * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-     * @param {string} itemId The id of the item from which the selection range should be expanded.
-     */
-    selectRangeFromItemToEnd: (event: React.SyntheticEvent, itemId: string) => void;
-    /**
-     * Update the selection when navigating with ArrowUp / ArrowDown keys.
-     * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-     * @param {string} currentItemId The id of the active item before the keyboard navigation.
-     * @param {string} nextItemId The id of the active item after the keyboard navigation.
-     */
-    selectItemFromArrowNavigation: (event: React.SyntheticEvent, currentItemId: string, nextItemId: string) => void;
+  /**
+   * Select all the navigable items in the tree.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   */
+  selectAllNavigableItems: (event: React.SyntheticEvent) => void;
+  /**
+   * Expand the current selection range up to the given item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string} itemId The id of the item to expand the selection to.
+   */
+  expandSelectionRange: (event: React.SyntheticEvent, itemId: string) => void;
+  /**
+   * Expand the current selection range from the first navigable item to the given item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string} itemId The id of the item up to which the selection range should be expanded.
+   */
+  selectRangeFromStartToItem: (event: React.SyntheticEvent, itemId: string) => void;
+  /**
+   * Expand the current selection range from the given item to the last navigable item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string} itemId The id of the item from which the selection range should be expanded.
+   */
+  selectRangeFromItemToEnd: (event: React.SyntheticEvent, itemId: string) => void;
+  /**
+   * Update the selection when navigating with ArrowUp / ArrowDown keys.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string} currentItemId The id of the active item before the keyboard navigation.
+   * @param {string} nextItemId The id of the active item after the keyboard navigation.
+   */
+  selectItemFromArrowNavigation: (event: React.SyntheticEvent, currentItemId: string, nextItemId: string) => void;
 }
 type TreeViewSelectionValue<Multiple extends boolean | undefined> = Multiple extends true ? string[] : string | null;
 export interface UseTreeViewSelectionParameters<Multiple extends boolean | undefined> {
-    /**
-     * If `true` selection is disabled.
-     * @default false
-     */
-    disableSelection?: boolean;
-    /**
-     * Selected item ids. (Uncontrolled)
-     * When `multiSelect` is true this takes an array of strings; when false (default) a string.
-     * @default []
-     */
-    defaultSelectedItems?: TreeViewSelectionValue<Multiple>;
-    /**
-     * Selected item ids. (Controlled)
-     * When `multiSelect` is true this takes an array of strings; when false (default) a string.
-     */
-    selectedItems?: TreeViewSelectionValue<Multiple>;
-    /**
-     * If `true`, `ctrl` and `shift` will trigger multiselect.
-     * @default false
-     */
-    multiSelect?: Multiple;
-    /**
-     * If `true`, the Tree View renders a checkbox at the left of its label that allows selecting it.
-     * @default false
-     */
-    checkboxSelection?: boolean;
-    /**
-     * When `selectionPropagation.descendants` is set to `true`.
-     *
-     * - Selecting a parent selects all its descendants automatically.
-     * - Deselecting a parent deselects all its descendants automatically.
-     *
-     * When `selectionPropagation.parents` is set to `true`.
-     *
-     * - Selecting all the descendants of a parent selects the parent automatically.
-     * - Deselecting a descendant of a selected parent deselects the parent automatically.
-     *
-     * Only works when `multiSelect` is `true`.
-     * On the <SimpleTreeView />, only the expanded items are considered (since the collapsed item are not passed to the Tree View component at all)
-     *
-     * @default { parents: false, descendants: false }
-     */
-    selectionPropagation?: TreeViewSelectionPropagation;
-    /**
-     * Callback fired when Tree Items are selected/deselected.
-     * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-     * @param {string[] | string} itemIds The ids of the selected items.
-     * When `multiSelect` is `true`, this is an array of strings; when false (default) a string.
-     */
-    onSelectedItemsChange?: (event: React.SyntheticEvent, itemIds: TreeViewSelectionValue<Multiple>) => void;
-    /**
-     * Callback fired when a Tree Item is selected or deselected.
-     * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-     * @param {array} itemId The itemId of the modified item.
-     * @param {array} isSelected `true` if the item has just been selected, `false` if it has just been deselected.
-     */
-    onItemSelectionToggle?: (event: React.SyntheticEvent, itemId: string, isSelected: boolean) => void;
+  /**
+   * If `true` selection is disabled.
+   * @default false
+   */
+  disableSelection?: boolean;
+  /**
+   * Selected item ids. (Uncontrolled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   * @default []
+   */
+  defaultSelectedItems?: TreeViewSelectionValue<Multiple>;
+  /**
+   * Selected item ids. (Controlled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   */
+  selectedItems?: TreeViewSelectionValue<Multiple>;
+  /**
+   * If `true`, `ctrl` and `shift` will trigger multiselect.
+   * @default false
+   */
+  multiSelect?: Multiple;
+  /**
+   * If `true`, the Tree View renders a checkbox at the left of its label that allows selecting it.
+   * @default false
+   */
+  checkboxSelection?: boolean;
+  /**
+   * When `selectionPropagation.descendants` is set to `true`.
+   *
+   * - Selecting a parent selects all its descendants automatically.
+   * - Deselecting a parent deselects all its descendants automatically.
+   *
+   * When `selectionPropagation.parents` is set to `true`.
+   *
+   * - Selecting all the descendants of a parent selects the parent automatically.
+   * - Deselecting a descendant of a selected parent deselects the parent automatically.
+   *
+   * Only works when `multiSelect` is `true`.
+   * On the <SimpleTreeView />, only the expanded items are considered (since the collapsed item are not passed to the Tree View component at all)
+   *
+   * @default { parents: false, descendants: false }
+   */
+  selectionPropagation?: TreeViewSelectionPropagation;
+  /**
+   * Callback fired when Tree Items are selected/deselected.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string[] | string} itemIds The ids of the selected items.
+   * When `multiSelect` is `true`, this is an array of strings; when false (default) a string.
+   */
+  onSelectedItemsChange?: (event: React.SyntheticEvent, itemIds: TreeViewSelectionValue<Multiple>) => void;
+  /**
+   * Callback fired when a Tree Item is selected or deselected.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {array} itemId The itemId of the modified item.
+   * @param {array} isSelected `true` if the item has just been selected, `false` if it has just been deselected.
+   */
+  onItemSelectionToggle?: (event: React.SyntheticEvent, itemId: string, isSelected: boolean) => void;
 }
 export type UseTreeViewSelectionDefaultizedParameters<Multiple extends boolean> = DefaultizedProps<UseTreeViewSelectionParameters<Multiple>, 'disableSelection' | 'defaultSelectedItems' | 'multiSelect' | 'checkboxSelection' | 'selectionPropagation'>;
 export interface UseTreeViewSelectionState {
-    selection: {
-        selectedItemsMap: Map<string, true>;
-    };
+  selection: {
+    selectedItemsMap: Map<string, true>;
+  };
 }
 interface UseTreeViewSelectionContextValue {
-    selection: Pick<UseTreeViewSelectionDefaultizedParameters<boolean>, 'multiSelect' | 'checkboxSelection' | 'disableSelection' | 'selectionPropagation'>;
+  selection: Pick<UseTreeViewSelectionDefaultizedParameters<boolean>, 'multiSelect' | 'checkboxSelection' | 'disableSelection' | 'selectionPropagation'>;
 }
 export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
-    params: UseTreeViewSelectionParameters<any>;
-    defaultizedParams: UseTreeViewSelectionDefaultizedParameters<any>;
-    instance: UseTreeViewSelectionInstance;
-    publicAPI: UseTreeViewSelectionPublicAPI;
-    contextValue: UseTreeViewSelectionContextValue;
-    modelNames: 'selectedItems';
-    state: UseTreeViewSelectionState;
-    dependencies: [
-        UseTreeViewItemsSignature,
-        UseTreeViewExpansionSignature,
-        UseTreeViewItemsSignature
-    ];
+  params: UseTreeViewSelectionParameters<any>;
+  defaultizedParams: UseTreeViewSelectionDefaultizedParameters<any>;
+  instance: UseTreeViewSelectionInstance;
+  publicAPI: UseTreeViewSelectionPublicAPI;
+  contextValue: UseTreeViewSelectionContextValue;
+  modelNames: 'selectedItems';
+  state: UseTreeViewSelectionState;
+  dependencies: [UseTreeViewItemsSignature, UseTreeViewExpansionSignature, UseTreeViewItemsSignature];
 }>;
 export interface UseTreeItemCheckboxSlotPropsFromSelection {
-    visible?: boolean;
-    checked?: boolean;
-    disabled?: boolean;
-    tabIndex?: -1;
-    onChange?: TreeViewCancellableEventHandler<React.ChangeEvent<HTMLInputElement>>;
+  visible?: boolean;
+  checked?: boolean;
+  disabled?: boolean;
+  tabIndex?: -1;
+  onChange?: TreeViewCancellableEventHandler<React.ChangeEvent<HTMLInputElement>>;
 }
 declare module '@mui/x-tree-view/useTreeItem' {
-    interface UseTreeItemCheckboxSlotOwnProps extends UseTreeItemCheckboxSlotPropsFromSelection {
-    }
+  interface UseTreeItemCheckboxSlotOwnProps extends UseTreeItemCheckboxSlotPropsFromSelection {}
 }
-export {};
+export {};

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.types.js

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

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

@@ -1,6 +1,6 @@
-import { TreeViewItemId, TreeViewSelectionPropagation } from '../../../models';
-import { TreeViewUsedStore } from '../../models';
-import { UseTreeViewSelectionSignature } from './useTreeViewSelection.types';
+import { TreeViewItemId, TreeViewSelectionPropagation } from "../../../models/index.js";
+import { TreeViewUsedStore } from "../../models/index.js";
+import { UseTreeViewSelectionSignature } from "./useTreeViewSelection.types.js";
 /**
  * Transform the `selectedItems` model to be an array if it was a string or null.
  * @param {string[] | string | null} model The raw model.
@@ -9,20 +9,30 @@ import { UseTreeViewSelectionSignature } from './useTreeViewSelection.types';
 export declare const convertSelectedItemsToArray: (model: string[] | string | null) => string[];
 export declare const createSelectedItemsMap: (selectedItems: string | string[] | null) => Map<string, true>;
 export declare const getLookupFromArray: (array: string[]) => {
-    [itemId: string]: true;
+  [itemId: string]: true;
 };
-export declare const getAddedAndRemovedItems: ({ store, oldModel, newModel, }: {
-    store: TreeViewUsedStore<UseTreeViewSelectionSignature>;
-    oldModel: TreeViewItemId[];
-    newModel: TreeViewItemId[];
+export declare const getAddedAndRemovedItems: ({
+  store,
+  oldModel,
+  newModel
+}: {
+  store: TreeViewUsedStore<UseTreeViewSelectionSignature>;
+  oldModel: TreeViewItemId[];
+  newModel: TreeViewItemId[];
 }) => {
-    added: string[];
-    removed: string[];
+  added: string[];
+  removed: string[];
 };
-export declare const propagateSelection: ({ store, selectionPropagation, newModel, oldModel, additionalItemsToPropagate, }: {
-    store: TreeViewUsedStore<UseTreeViewSelectionSignature>;
-    selectionPropagation: TreeViewSelectionPropagation;
-    newModel: TreeViewItemId[];
-    oldModel: TreeViewItemId[];
-    additionalItemsToPropagate?: TreeViewItemId[];
-}) => string[];
+export declare const propagateSelection: ({
+  store,
+  selectionPropagation,
+  newModel,
+  oldModel,
+  additionalItemsToPropagate
+}: {
+  store: TreeViewUsedStore<UseTreeViewSelectionSignature>;
+  selectionPropagation: TreeViewSelectionPropagation;
+  newModel: TreeViewItemId[];
+  oldModel: TreeViewItemId[];
+  additionalItemsToPropagate?: TreeViewItemId[];
+}) => string[];

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.utils.js

@@ -1,12 +1,17 @@
-import { selectorIsItemSelected } from "./useTreeViewSelection.selectors.js";
-import { selectorItemOrderedChildrenIds, selectorItemParentId } from "../useTreeViewItems/useTreeViewItems.selectors.js";
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.propagateSelection = exports.getLookupFromArray = exports.getAddedAndRemovedItems = exports.createSelectedItemsMap = exports.convertSelectedItemsToArray = void 0;
+var _useTreeViewSelection = require("./useTreeViewSelection.selectors");
+var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
 /**
  * Transform the `selectedItems` model to be an array if it was a string or null.
  * @param {string[] | string | null} model The raw model.
  * @returns {string[]} The converted model.
  */
-export const convertSelectedItemsToArray = model => {
+const convertSelectedItemsToArray = model => {
   if (Array.isArray(model)) {
     return model;
   }
@@ -15,32 +20,36 @@ export const convertSelectedItemsToArray = model => {
   }
   return [];
 };
-export const createSelectedItemsMap = selectedItems => {
+exports.convertSelectedItemsToArray = convertSelectedItemsToArray;
+const createSelectedItemsMap = selectedItems => {
   const selectedItemsMap = new Map();
   convertSelectedItemsToArray(selectedItems).forEach(id => {
     selectedItemsMap.set(id, true);
   });
   return selectedItemsMap;
 };
-export const getLookupFromArray = array => {
+exports.createSelectedItemsMap = createSelectedItemsMap;
+const getLookupFromArray = array => {
   const lookup = {};
   array.forEach(itemId => {
     lookup[itemId] = true;
   });
   return lookup;
 };
-export const getAddedAndRemovedItems = ({
+exports.getLookupFromArray = getLookupFromArray;
+const getAddedAndRemovedItems = ({
   store,
   oldModel,
   newModel
 }) => {
   const newModelLookup = createSelectedItemsMap(newModel);
   return {
-    added: newModel.filter(itemId => !selectorIsItemSelected(store.value, itemId)),
+    added: newModel.filter(itemId => !(0, _useTreeViewSelection.selectorIsItemSelected)(store.value, itemId)),
     removed: oldModel.filter(itemId => !newModelLookup.has(itemId))
   };
 };
-export const propagateSelection = ({
+exports.getAddedAndRemovedItems = getAddedAndRemovedItems;
+const propagateSelection = ({
   store,
   selectionPropagation,
   newModel,
@@ -73,7 +82,7 @@ export const propagateSelection = ({
           shouldRegenerateModel = true;
           newModelLookup[itemId] = true;
         }
-        selectorItemOrderedChildrenIds(store.value, itemId).forEach(selectDescendants);
+        (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId).forEach(selectDescendants);
       };
       selectDescendants(addedItemId);
     }
@@ -82,15 +91,15 @@ export const propagateSelection = ({
         if (!newModelLookup[itemId]) {
           return false;
         }
-        const children = selectorItemOrderedChildrenIds(store.value, itemId);
+        const children = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId);
         return children.every(checkAllDescendantsSelected);
       };
       const selectParents = itemId => {
-        const parentId = selectorItemParentId(store.value, itemId);
+        const parentId = (0, _useTreeViewItems.selectorItemParentId)(store.value, itemId);
         if (parentId == null) {
           return;
         }
-        const siblings = selectorItemOrderedChildrenIds(store.value, parentId);
+        const siblings = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, parentId);
         if (siblings.every(checkAllDescendantsSelected)) {
           shouldRegenerateModel = true;
           newModelLookup[parentId] = true;
@@ -102,13 +111,13 @@ export const propagateSelection = ({
   });
   changes.removed.forEach(removedItemId => {
     if (selectionPropagation.parents) {
-      let parentId = selectorItemParentId(store.value, removedItemId);
+      let parentId = (0, _useTreeViewItems.selectorItemParentId)(store.value, removedItemId);
       while (parentId != null) {
         if (newModelLookup[parentId]) {
           shouldRegenerateModel = true;
           delete newModelLookup[parentId];
         }
-        parentId = selectorItemParentId(store.value, parentId);
+        parentId = (0, _useTreeViewItems.selectorItemParentId)(store.value, parentId);
       }
     }
     if (selectionPropagation.descendants) {
@@ -117,10 +126,11 @@ export const propagateSelection = ({
           shouldRegenerateModel = true;
           delete newModelLookup[itemId];
         }
-        selectorItemOrderedChildrenIds(store.value, itemId).forEach(deSelectDescendants);
+        (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId).forEach(deSelectDescendants);
       };
       deSelectDescendants(removedItemId);
     }
   });
   return shouldRegenerateModel ? Object.keys(newModelLookup) : newModel;
-};
+};
+exports.propagateSelection = propagateSelection;

package/internals/useTreeView/extractPluginParamsFromProps.d.ts

@@ -1,13 +1,22 @@
-import { ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewAnyPluginSignature, TreeViewPluginSignature } from '../models';
-import { UseTreeViewBaseProps } from './useTreeView.types';
-import { TreeViewCorePluginSignatures } from '../corePlugins';
+import { ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewAnyPluginSignature, TreeViewPluginSignature } from "../models/index.js";
+import { UseTreeViewBaseProps } from "./useTreeView.types.js";
+import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
 interface ExtractPluginParamsFromPropsParameters<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> {
-    plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>;
-    props: TProps;
+  plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>;
+  props: TProps;
 }
 interface ExtractPluginParamsFromPropsReturnValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> extends UseTreeViewBaseProps<TSignatures> {
-    pluginParams: MergeSignaturesProperty<TSignatures, 'defaultizedParams'>;
-    forwardedProps: Omit<TProps, keyof MergeSignaturesProperty<TSignatures, 'params'>>;
+  pluginParams: MergeSignaturesProperty<TSignatures, 'defaultizedParams'>;
+  forwardedProps: Omit<TProps, keyof MergeSignaturesProperty<TSignatures, 'params'>>;
 }
-export declare const extractPluginParamsFromProps: <TSignatures extends readonly TreeViewPluginSignature<any>[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({ props: { slots, slotProps, apiRef, experimentalFeatures: inExperimentalFeatures, ...props }, plugins, }: ExtractPluginParamsFromPropsParameters<TSignatures, TProps>) => ExtractPluginParamsFromPropsReturnValue<TSignatures, TProps>;
-export {};
+export declare const extractPluginParamsFromProps: <TSignatures extends readonly TreeViewPluginSignature<any>[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
+  props: {
+    slots,
+    slotProps,
+    apiRef,
+    experimentalFeatures: inExperimentalFeatures,
+    ...props
+  },
+  plugins
+}: ExtractPluginParamsFromPropsParameters<TSignatures, TProps>) => ExtractPluginParamsFromPropsReturnValue<TSignatures, TProps>;
+export {};

package/internals/useTreeView/extractPluginParamsFromProps.js

@@ -1,6 +1,13 @@
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractPluginParamsFromProps = void 0;
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
 const _excluded = ["slots", "slotProps", "apiRef", "experimentalFeatures"];
-export const extractPluginParamsFromProps = _ref => {
+const extractPluginParamsFromProps = _ref => {
   let {
       props: {
         slots,
@@ -10,7 +17,7 @@ export const extractPluginParamsFromProps = _ref => {
       },
       plugins
     } = _ref,
-    props = _objectWithoutPropertiesLoose(_ref.props, _excluded);
+    props = (0, _objectWithoutPropertiesLoose2.default)(_ref.props, _excluded);
   const paramsLookup = {};
   plugins.forEach(plugin => {
     Object.assign(paramsLookup, plugin.params);
@@ -43,4 +50,5 @@ export const extractPluginParamsFromProps = _ref => {
     slotProps: slotProps ?? {},
     experimentalFeatures
   };
-};
+};
+exports.extractPluginParamsFromProps = extractPluginParamsFromProps;

package/internals/useTreeView/index.d.ts

@@ -1 +1 @@
-export { useTreeView } from './useTreeView';
+export { useTreeView } from "./useTreeView.js";

package/internals/useTreeView/index.js

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

package/internals/useTreeView/useTreeView.d.ts

@@ -1,5 +1,9 @@
 import * as React from 'react';
-import { TreeViewAnyPluginSignature } from '../models';
-import { UseTreeViewBaseProps, UseTreeViewParameters, UseTreeViewReturnValue } from './useTreeView.types';
+import { TreeViewAnyPluginSignature } from "../models/index.js";
+import { UseTreeViewBaseProps, UseTreeViewParameters, UseTreeViewReturnValue } from "./useTreeView.types.js";
 export declare function useTreeViewApiInitialization<T>(inputApiRef: React.RefObject<T | undefined> | undefined): T;
-export declare const useTreeView: <TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({ plugins: inPlugins, rootRef, props, }: UseTreeViewParameters<TSignatures, TProps>) => UseTreeViewReturnValue<TSignatures>;
+export declare const useTreeView: <TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
+  plugins: inPlugins,
+  rootRef,
+  props
+}: UseTreeViewParameters<TSignatures, TProps>) => UseTreeViewReturnValue<TSignatures>;