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

package/esm/internals/plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.selectors.d.ts

@@ -0,0 +1,249 @@
+import { TreeViewAnyPluginSignature, TreeViewState } from "../../models/index.js";
+import { TreeViewRootSelector, TreeViewRootSelectorForOptionalPlugin } from "../../utils/selectors.js";
+import { UseTreeViewLazyLoadingSignature } from "./useTreeViewLazyLoading.types.js";
+export type Temp<TSignature extends TreeViewAnyPluginSignature> = <TSignatures extends [], TOptionalSignatures extends [TSignature]>(state: TreeViewState<TSignatures, TOptionalSignatures>) => TSignature['state'][keyof TSignature['state']];
+export declare const selectorDataSourceState: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewLazyLoading.types").UseTreeViewLazyLoadingState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => {
+  loading: Record<import("../../..").TreeViewItemId, boolean>;
+  errors: Record<import("../../..").TreeViewItemId, Error | null>;
+}) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    enabled: boolean;
+    dataSource: {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+  }) => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  };
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    enabled: boolean;
+    dataSource: {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+  }) => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  };
+  dependencies: [TreeViewRootSelector<UseTreeViewLazyLoadingSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if lazy loading is enabled.
+ * @param {TreeViewState<[UseTreeViewLazyLoadingSignature]>} state The state of the tree view.
+ * @returns {boolean} True if lazy loading is enabled, false if it isn't.
+ */
+export declare const selectorIsLazyLoadingEnabled: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & Partial<import("./useTreeViewLazyLoading.types").UseTreeViewLazyLoadingState> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    enabled: boolean;
+    dataSource: {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+  } | undefined) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    enabled: boolean;
+    dataSource: {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+  } | undefined) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelectorForOptionalPlugin<UseTreeViewLazyLoadingSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get the loading state for a tree item.
+ * @param {TreeViewState<[UseTreeViewLazyLoadingSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to get the loading state of.
+ * @returns {boolean} The loading state for the Tree Item.
+ */
+export declare const selectorIsItemLoading: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }, resultFuncArgs_1: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewLazyLoading.types").UseTreeViewLazyLoadingState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      enabled: boolean;
+      dataSource: {
+        loading: Record<import("../../..").TreeViewItemId, boolean>;
+        errors: Record<import("../../..").TreeViewItemId, Error | null>;
+      };
+    }) => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      enabled: boolean;
+      dataSource: {
+        loading: Record<import("../../..").TreeViewItemId, boolean>;
+        errors: Record<import("../../..").TreeViewItemId, Error | null>;
+      };
+    }) => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    }) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+    dependencies: [TreeViewRootSelector<UseTreeViewLazyLoadingSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get the error for a tree item.
+ * @param {TreeViewState<[UseTreeViewLazyLoadingSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to get the error for.
+ * @returns {boolean} The error for the Tree Item.
+ */
+export declare const selectorGetTreeItemError: ((state: any, itemId: string) => Error | null) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }, resultFuncArgs_1: string) => Error | null;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }, resultFuncArgs_1: string) => Error | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => Error | null;
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewLazyLoading.types").UseTreeViewLazyLoadingState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      enabled: boolean;
+      dataSource: {
+        loading: Record<import("../../..").TreeViewItemId, boolean>;
+        errors: Record<import("../../..").TreeViewItemId, Error | null>;
+      };
+    }) => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      enabled: boolean;
+      dataSource: {
+        loading: Record<import("../../..").TreeViewItemId, boolean>;
+        errors: Record<import("../../..").TreeViewItemId, Error | null>;
+      };
+    }) => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    }) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+    dependencies: [TreeViewRootSelector<UseTreeViewLazyLoadingSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

package/esm/internals/plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.selectors.js

@@ -0,0 +1,27 @@
+import { createSelector } from "../../utils/selectors.js";
+const selectorLazyLoading = state => state.lazyLoading;
+const selectorLazyLoadingOptional = state => state.lazyLoading;
+export const selectorDataSourceState = createSelector([selectorLazyLoading], lazyLoading => lazyLoading.dataSource);
+
+/**
+ * Check if lazy loading is enabled.
+ * @param {TreeViewState<[UseTreeViewLazyLoadingSignature]>} state The state of the tree view.
+ * @returns {boolean} True if lazy loading is enabled, false if it isn't.
+ */
+export const selectorIsLazyLoadingEnabled = createSelector([selectorLazyLoadingOptional], lazyLoading => !!lazyLoading?.enabled);
+
+/**
+ * Get the loading state for a tree item.
+ * @param {TreeViewState<[UseTreeViewLazyLoadingSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to get the loading state of.
+ * @returns {boolean} The loading state for the Tree Item.
+ */
+export const selectorIsItemLoading = createSelector([selectorDataSourceState, (_, itemId) => itemId], (dataSourceState, itemId) => dataSourceState.loading[itemId] || false);
+
+/**
+ * Get the error for a tree item.
+ * @param {TreeViewState<[UseTreeViewLazyLoadingSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to get the error for.
+ * @returns {boolean} The error for the Tree Item.
+ */
+export const selectorGetTreeItemError = createSelector([selectorDataSourceState, (_, itemId) => itemId], (dataSourceState, itemId) => dataSourceState.errors[itemId] || null);

package/esm/internals/plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.types.d.ts

@@ -0,0 +1,83 @@
+import { DefaultizedProps } from '@mui/x-internals/types';
+import { TreeViewPluginSignature } from "../../models/index.js";
+import { DataSourceCache } from "../../../utils/index.js";
+import { TreeViewItemId } from "../../../models/index.js";
+import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
+import { UseTreeViewExpansionSignature } from "../useTreeViewExpansion/index.js";
+import { UseTreeViewSelectionSignature } from "../useTreeViewSelection/index.js";
+type DataSource<R extends {}> = {
+  /**
+   * Used to determine the number of children the item has.
+   * Only relevant for lazy-loaded trees.
+   *
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {number} The number of children.
+   * @default (item) => number
+   */
+  getChildrenCount?: (item: R) => number;
+  /**
+   * Method used for fetching the items.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @template R
+   * @param {TreeViewItemId} parentId The id of the item the children belong to.
+   * @returns { Promise<R[]>} The children of the item.
+   */
+  getTreeItems?: (parentId?: TreeViewItemId) => Promise<R[]>;
+};
+export interface UseTreeViewLazyLoadingPublicAPI {}
+export interface UseTreeViewLazyLoadingInstance extends UseTreeViewLazyLoadingPublicAPI {
+  /**
+   * Method used for fetching multiple items concurrently.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @param {TreeViewItemId[]} parentIds The ids of the items to fetch the children of.
+   * @returns { Promise<void>} The children of the items.
+   */
+  fetchItems: (parentIds?: TreeViewItemId[]) => Promise<void>;
+  /**
+   * Method used for fetching and item's children.
+   * Only relevant for lazy-loaded tree views.
+   *
+   * @param {TreeViewItemId} itemId The The id of the item to fetch the children of.
+   * @returns { Promise<void>} The children of the item.
+   */
+  fetchItemChildren: (itemId: TreeViewItemId) => Promise<void>;
+  /**
+   * Set the loading state of an item.
+   * @param {TreeViewItemId} itemId The id of the item to set the loading state of.
+   * @param {boolean} isLoading True if the item is loading.
+   */
+  setDataSourceLoading: (itemId: TreeViewItemId, isLoading: boolean) => void;
+  /**
+   * Set the error state of an item.
+   * @param {TreeViewItemId} itemId The id of the item to set the error state of.
+   * @param {Error | null} error The error caught on the item.
+   */
+  setDataSourceError: (itemId: TreeViewItemId, error: Error | null) => void;
+}
+export interface UseTreeViewLazyLoadingParameters<R extends {}> {
+  dataSource?: DataSource<R>;
+  dataSourceCache?: DataSourceCache;
+}
+export type UseTreeViewLazyLoadingDefaultizedParameters<R extends {}> = DefaultizedProps<UseTreeViewLazyLoadingParameters<R>, 'dataSource'>;
+export interface UseTreeViewLazyLoadingState {
+  lazyLoading: {
+    enabled: boolean;
+    dataSource: {
+      loading: Record<TreeViewItemId, boolean>;
+      errors: Record<TreeViewItemId, Error | null>;
+    };
+  };
+}
+export type UseTreeViewLazyLoadingSignature = TreeViewPluginSignature<{
+  params: UseTreeViewLazyLoadingParameters<any>;
+  defaultizedParams: UseTreeViewLazyLoadingDefaultizedParameters<any>;
+  publicAPI: UseTreeViewLazyLoadingPublicAPI;
+  instance: UseTreeViewLazyLoadingInstance;
+  state: UseTreeViewLazyLoadingState;
+  experimentalFeatures: 'lazyLoading';
+  dependencies: [UseTreeViewItemsSignature, UseTreeViewExpansionSignature, UseTreeViewSelectionSignature];
+}>;
+export {};

package/esm/internals/plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.types.js

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

package/esm/internals/plugins/useTreeViewSelection/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewSelection } from "./useTreeViewSelection.js";
+export type { UseTreeViewSelectionSignature, UseTreeViewSelectionParameters, UseTreeViewSelectionDefaultizedParameters } from './useTreeViewSelection.types';

package/esm/internals/plugins/useTreeViewSelection/index.js

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

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

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

package/esm/internals/plugins/useTreeViewSelection/useTreeViewSelection.itemPlugin.d.ts

@@ -0,0 +1,2 @@
+import { TreeViewItemPlugin } from "../../models/index.js";
+export declare const useTreeViewSelectionItemPlugin: TreeViewItemPlugin;

package/{node → esm}/internals/plugins/useTreeViewSelection/useTreeViewSelection.itemPlugin.js

@@ -1,26 +1,19 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTreeViewSelectionItemPlugin = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var _TreeViewProvider = require("../../TreeViewProvider");
-var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
-var _useTreeViewSelection = require("./useTreeViewSelection.selectors");
-var _useSelector = require("../../hooks/useSelector");
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { useTreeViewContext } from "../../TreeViewProvider/index.js";
+import { selectorItemOrderedChildrenIds } from "../useTreeViewItems/useTreeViewItems.selectors.js";
+import { selectorIsItemSelected } from "./useTreeViewSelection.selectors.js";
+import { useSelector } from "../../hooks/useSelector.js";
 function selectorItemCheckboxStatus(state, {
   itemId,
   selectionPropagation
 }) {
-  if ((0, _useTreeViewSelection.selectorIsItemSelected)(state, itemId)) {
+  if (selectorIsItemSelected(state, itemId)) {
     return {
       indeterminate: false,
       checked: true
     };
   }
-  const children = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, itemId);
+  const children = selectorItemOrderedChildrenIds(state, itemId);
   if (children.length === 0) {
     return {
       indeterminate: false,
@@ -31,13 +24,13 @@ function selectorItemCheckboxStatus(state, {
   let hasUnSelectedDescendant = false;
   const traverseDescendants = itemToTraverseId => {
     if (itemToTraverseId !== itemId) {
-      if ((0, _useTreeViewSelection.selectorIsItemSelected)(state, itemToTraverseId)) {
+      if (selectorIsItemSelected(state, itemToTraverseId)) {
         hasSelectedDescendant = true;
       } else {
         hasUnSelectedDescendant = true;
       }
     }
-    (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, itemToTraverseId).forEach(traverseDescendants);
+    selectorItemOrderedChildrenIds(state, itemToTraverseId).forEach(traverseDescendants);
   };
   traverseDescendants(itemId);
   return {
@@ -45,7 +38,7 @@ function selectorItemCheckboxStatus(state, {
     checked: selectionPropagation.parents ? hasSelectedDescendant : false
   };
 }
-const useTreeViewSelectionItemPlugin = ({
+export const useTreeViewSelectionItemPlugin = ({
   props
 }) => {
   const {
@@ -58,8 +51,8 @@ const useTreeViewSelectionItemPlugin = ({
       checkboxSelection,
       selectionPropagation
     }
-  } = (0, _TreeViewProvider.useTreeViewContext)();
-  const checkboxStatus = (0, _useSelector.useSelector)(store, selectorItemCheckboxStatus, {
+  } = useTreeViewContext();
+  const checkboxStatus = useSelector(store, selectorItemCheckboxStatus, {
     itemId,
     selectionPropagation
   }, (a, b) => a.checked === b.checked && a.indeterminate === b.indeterminate);
@@ -80,7 +73,7 @@ const useTreeViewSelectionItemPlugin = ({
           }
           interactions.handleCheckboxSelection(event);
         };
-        return (0, _extends2.default)({
+        return _extends({
           visible: checkboxSelection,
           disabled: disableSelection || status.disabled,
           tabIndex: -1,
@@ -89,5 +82,4 @@ const useTreeViewSelectionItemPlugin = ({
       }
     }
   };
-};
-exports.useTreeViewSelectionItemPlugin = useTreeViewSelectionItemPlugin;
+};

package/{node → esm}/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -1,36 +1,28 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTreeViewSelection = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var React = _interopRequireWildcard(require("react"));
-var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedEffect"));
-var _tree = require("../../utils/tree");
-var _useTreeViewSelection = require("./useTreeViewSelection.utils");
-var _useTreeViewSelection2 = require("./useTreeViewSelection.selectors");
-var _useTreeViewSelection3 = require("./useTreeViewSelection.itemPlugin");
-const useTreeViewSelection = ({
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import { findOrderInTremauxTree, getAllNavigableItems, getFirstNavigableItem, getLastNavigableItem, getNonDisabledItemsInRange } from "../../utils/tree.js";
+import { convertSelectedItemsToArray, propagateSelection, getAddedAndRemovedItems, getLookupFromArray, createSelectedItemsMap } from "./useTreeViewSelection.utils.js";
+import { selectorIsItemSelected } from "./useTreeViewSelection.selectors.js";
+import { useTreeViewSelectionItemPlugin } from "./useTreeViewSelection.itemPlugin.js";
+export const useTreeViewSelection = ({
   store,
   params,
   models
 }) => {
   const lastSelectedItem = React.useRef(null);
   const lastSelectedRange = React.useRef({});
-  (0, _useEnhancedEffect.default)(() => {
-    store.update(prevState => (0, _extends2.default)({}, prevState, {
+  useEnhancedEffect(() => {
+    store.update(prevState => _extends({}, prevState, {
       selection: {
-        selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(models.selectedItems.value)
+        selectedItemsMap: createSelectedItemsMap(models.selectedItems.value)
       }
     }));
   }, [store, models.selectedItems.value]);
   const setSelectedItems = (event, newModel, additionalItemsToPropagate) => {
     let cleanModel;
     if (params.multiSelect && (params.selectionPropagation.descendants || params.selectionPropagation.parents)) {
-      cleanModel = (0, _useTreeViewSelection.propagateSelection)({
+      cleanModel = propagateSelection({
         store,
         selectionPropagation: params.selectionPropagation,
         newModel: newModel,
@@ -42,7 +34,7 @@ const useTreeViewSelection = ({
     }
     if (params.onItemSelectionToggle) {
       if (params.multiSelect) {
-        const changes = (0, _useTreeViewSelection.getAddedAndRemovedItems)({
+        const changes = getAddedAndRemovedItems({
           store,
           newModel: cleanModel,
           oldModel: models.selectedItems.value
@@ -69,9 +61,9 @@ const useTreeViewSelection = ({
     }
     models.selectedItems.setControlledValue(cleanModel);
   };
-  const selectItem = ({
-    event,
+  const setItemSelection = ({
     itemId,
+    event = null,
     keepExistingSelection = false,
     shouldBeSelected
   }) => {
@@ -80,8 +72,8 @@ const useTreeViewSelection = ({
     }
     let newSelected;
     if (keepExistingSelection) {
-      const cleanSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value);
-      const isSelectedBefore = (0, _useTreeViewSelection2.selectorIsItemSelected)(store.value, itemId);
+      const cleanSelectedItems = convertSelectedItemsToArray(models.selectedItems.value);
+      const isSelectedBefore = selectorIsItemSelected(store.value, itemId);
       if (isSelectedBefore && (shouldBeSelected === false || shouldBeSelected == null)) {
         newSelected = cleanSelectedItems.filter(id => id !== itemId);
       } else if (!isSelectedBefore && (shouldBeSelected === true || shouldBeSelected == null)) {
@@ -91,7 +83,7 @@ const useTreeViewSelection = ({
       }
     } else {
       // eslint-disable-next-line no-lonely-if
-      if (shouldBeSelected === false || shouldBeSelected == null && (0, _useTreeViewSelection2.selectorIsItemSelected)(store.value, itemId)) {
+      if (shouldBeSelected === false || shouldBeSelected == null && selectorIsItemSelected(store.value, itemId)) {
         newSelected = params.multiSelect ? [] : null;
       } else {
         newSelected = params.multiSelect ? [itemId] : itemId;
@@ -108,7 +100,7 @@ const useTreeViewSelection = ({
     if (params.disableSelection || !params.multiSelect) {
       return;
     }
-    let newSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value).slice();
+    let newSelectedItems = convertSelectedItemsToArray(models.selectedItems.value).slice();
 
     // If the last selection was a range selection,
     // remove the items that were part of the last range from the model
@@ -117,38 +109,38 @@ const useTreeViewSelection = ({
     }
 
     // Add to the model the items that are part of the new range and not already part of the model.
-    const selectedItemsLookup = (0, _useTreeViewSelection.getLookupFromArray)(newSelectedItems);
-    const range = (0, _tree.getNonDisabledItemsInRange)(store.value, start, end);
+    const selectedItemsLookup = getLookupFromArray(newSelectedItems);
+    const range = getNonDisabledItemsInRange(store.value, start, end);
     const itemsToAddToModel = range.filter(id => !selectedItemsLookup[id]);
     newSelectedItems = newSelectedItems.concat(itemsToAddToModel);
     setSelectedItems(event, newSelectedItems);
-    lastSelectedRange.current = (0, _useTreeViewSelection.getLookupFromArray)(range);
+    lastSelectedRange.current = getLookupFromArray(range);
   };
   const expandSelectionRange = (event, itemId) => {
     if (lastSelectedItem.current != null) {
-      const [start, end] = (0, _tree.findOrderInTremauxTree)(store.value, itemId, lastSelectedItem.current);
+      const [start, end] = findOrderInTremauxTree(store.value, itemId, lastSelectedItem.current);
       selectRange(event, [start, end]);
     }
   };
   const selectRangeFromStartToItem = (event, itemId) => {
-    selectRange(event, [(0, _tree.getFirstNavigableItem)(store.value), itemId]);
+    selectRange(event, [getFirstNavigableItem(store.value), itemId]);
   };
   const selectRangeFromItemToEnd = (event, itemId) => {
-    selectRange(event, [itemId, (0, _tree.getLastNavigableItem)(store.value)]);
+    selectRange(event, [itemId, getLastNavigableItem(store.value)]);
   };
   const selectAllNavigableItems = event => {
     if (params.disableSelection || !params.multiSelect) {
       return;
     }
-    const navigableItems = (0, _tree.getAllNavigableItems)(store.value);
+    const navigableItems = getAllNavigableItems(store.value);
     setSelectedItems(event, navigableItems);
-    lastSelectedRange.current = (0, _useTreeViewSelection.getLookupFromArray)(navigableItems);
+    lastSelectedRange.current = getLookupFromArray(navigableItems);
   };
   const selectItemFromArrowNavigation = (event, currentItem, nextItem) => {
     if (params.disableSelection || !params.multiSelect) {
       return;
     }
-    let newSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value).slice();
+    let newSelectedItems = convertSelectedItemsToArray(models.selectedItems.value).slice();
     if (Object.keys(lastSelectedRange.current).length === 0) {
       newSelectedItems.push(nextItem);
       lastSelectedRange.current = {
@@ -185,10 +177,10 @@ const useTreeViewSelection = ({
       'aria-multiselectable': params.multiSelect
     }),
     publicAPI: {
-      selectItem
+      setItemSelection
     },
     instance: {
-      selectItem,
+      setItemSelection,
       selectAllNavigableItems,
       expandSelectionRange,
       selectRangeFromStartToItem,
@@ -198,8 +190,7 @@ const useTreeViewSelection = ({
     contextValue: pluginContextValue
   };
 };
-exports.useTreeViewSelection = useTreeViewSelection;
-useTreeViewSelection.itemPlugin = _useTreeViewSelection3.useTreeViewSelectionItemPlugin;
+useTreeViewSelection.itemPlugin = useTreeViewSelectionItemPlugin;
 useTreeViewSelection.models = {
   selectedItems: {
     getDefaultValue: params => params.defaultSelectedItems
@@ -209,7 +200,7 @@ const DEFAULT_SELECTED_ITEMS = [];
 const EMPTY_SELECTION_PROPAGATION = {};
 useTreeViewSelection.getDefaultizedParams = ({
   params
-}) => (0, _extends2.default)({}, params, {
+}) => _extends({}, params, {
   disableSelection: params.disableSelection ?? false,
   multiSelect: params.multiSelect ?? false,
   checkboxSelection: params.checkboxSelection ?? false,
@@ -218,12 +209,12 @@ useTreeViewSelection.getDefaultizedParams = ({
 });
 useTreeViewSelection.getInitialState = params => ({
   selection: {
-    selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
+    selectedItemsMap: createSelectedItemsMap(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
   }
 });
 useTreeViewSelection.getInitialState = params => ({
   selection: {
-    selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
+    selectedItemsMap: createSelectedItemsMap(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
   }
 });
 useTreeViewSelection.params = {