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

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.itemPlugin.js

@@ -6,16 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useTreeViewSelectionItemPlugin = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _fastObjectShallowCompare = require("@mui/x-internals/fastObjectShallowCompare");
 var _TreeViewProvider = require("../../TreeViewProvider");
 var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
 var _useTreeViewSelection = require("./useTreeViewSelection.selectors");
 var _useSelector = require("../../hooks/useSelector");
-function selectorItemCheckboxStatus(state, {
-  itemId,
-  selectionPropagation
-}) {
+function selectorItemCheckboxStatus(state, itemId) {
+  const isCheckboxSelectionEnabled = (0, _useTreeViewSelection.selectorIsCheckboxSelectionEnabled)(state);
+  const isSelectionEnabledForItem = (0, _useTreeViewSelection.selectorIsItemSelectionEnabled)(state, itemId);
   if ((0, _useTreeViewSelection.selectorIsItemSelected)(state, itemId)) {
     return {
+      disabled: !isSelectionEnabledForItem,
+      visible: isCheckboxSelectionEnabled,
       indeterminate: false,
       checked: true
     };
@@ -23,6 +25,8 @@ function selectorItemCheckboxStatus(state, {
   const children = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(state, itemId);
   if (children.length === 0) {
     return {
+      disabled: !isSelectionEnabledForItem,
+      visible: isCheckboxSelectionEnabled,
       indeterminate: false,
       checked: false
     };
@@ -41,8 +45,10 @@ function selectorItemCheckboxStatus(state, {
   };
   traverseDescendants(itemId);
   return {
+    disabled: !isSelectionEnabledForItem,
+    visible: isCheckboxSelectionEnabled,
     indeterminate: hasSelectedDescendant && hasUnSelectedDescendant || !hasUnSelectedDescendant,
-    checked: selectionPropagation.parents ? hasSelectedDescendant : false
+    checked: (0, _useTreeViewSelection.selectorSelectionPropagationRules)(state).parents ? hasSelectedDescendant : false
   };
 }
 const useTreeViewSelectionItemPlugin = ({
@@ -52,37 +58,26 @@ const useTreeViewSelectionItemPlugin = ({
     itemId
   } = props;
   const {
-    store,
-    selection: {
-      disableSelection,
-      checkboxSelection,
-      selectionPropagation
-    }
+    store
   } = (0, _TreeViewProvider.useTreeViewContext)();
-  const checkboxStatus = (0, _useSelector.useSelector)(store, selectorItemCheckboxStatus, {
-    itemId,
-    selectionPropagation
-  }, (a, b) => a.checked === b.checked && a.indeterminate === b.indeterminate);
+  const checkboxStatus = (0, _useSelector.useSelector)(store, selectorItemCheckboxStatus, itemId, _fastObjectShallowCompare.fastObjectShallowCompare);
   return {
     propsEnhancers: {
       checkbox: ({
         externalEventHandlers,
-        interactions,
-        status
+        interactions
       }) => {
         const handleChange = event => {
           externalEventHandlers.onChange?.(event);
           if (event.defaultMuiPrevented) {
             return;
           }
-          if (disableSelection || status.disabled) {
+          if (!(0, _useTreeViewSelection.selectorIsItemSelectionEnabled)(store.value, itemId)) {
             return;
           }
           interactions.handleCheckboxSelection(event);
         };
         return (0, _extends2.default)({
-          visible: checkboxSelection,
-          disabled: disableSelection || status.disabled,
           tabIndex: -1,
           onChange: handleChange
         }, checkboxStatus);

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -20,16 +20,10 @@ const useTreeViewSelection = ({
 }) => {
   const lastSelectedItem = React.useRef(null);
   const lastSelectedRange = React.useRef({});
-  (0, _useEnhancedEffect.default)(() => {
-    store.update(prevState => (0, _extends2.default)({}, prevState, {
-      selection: {
-        selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(models.selectedItems.value)
-      }
-    }));
-  }, [store, models.selectedItems.value]);
   const setSelectedItems = (event, newModel, additionalItemsToPropagate) => {
     let cleanModel;
-    if (params.multiSelect && (params.selectionPropagation.descendants || params.selectionPropagation.parents)) {
+    const isMultiSelectEnabled = (0, _useTreeViewSelection2.selectorIsMultiSelectEnabled)(store.value);
+    if (isMultiSelectEnabled && (params.selectionPropagation.descendants || params.selectionPropagation.parents)) {
       cleanModel = (0, _useTreeViewSelection.propagateSelection)({
         store,
         selectionPropagation: params.selectionPropagation,
@@ -41,7 +35,7 @@ const useTreeViewSelection = ({
       cleanModel = newModel;
     }
     if (params.onItemSelectionToggle) {
-      if (params.multiSelect) {
+      if (isMultiSelectEnabled) {
         const changes = (0, _useTreeViewSelection.getAddedAndRemovedItems)({
           store,
           newModel: cleanModel,
@@ -75,10 +69,11 @@ const useTreeViewSelection = ({
     keepExistingSelection = false,
     shouldBeSelected
   }) => {
-    if (params.disableSelection) {
+    if (!(0, _useTreeViewSelection2.selectorIsSelectionEnabled)(store.value)) {
       return;
     }
     let newSelected;
+    const isMultiSelectEnabled = (0, _useTreeViewSelection2.selectorIsMultiSelectEnabled)(store.value);
     if (keepExistingSelection) {
       const cleanSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value);
       const isSelectedBefore = (0, _useTreeViewSelection2.selectorIsItemSelected)(store.value, itemId);
@@ -92,9 +87,9 @@ const useTreeViewSelection = ({
     } else {
       // eslint-disable-next-line no-lonely-if
       if (shouldBeSelected === false || shouldBeSelected == null && (0, _useTreeViewSelection2.selectorIsItemSelected)(store.value, itemId)) {
-        newSelected = params.multiSelect ? [] : null;
+        newSelected = isMultiSelectEnabled ? [] : null;
       } else {
-        newSelected = params.multiSelect ? [itemId] : itemId;
+        newSelected = isMultiSelectEnabled ? [itemId] : itemId;
       }
     }
     setSelectedItems(event, newSelected,
@@ -105,7 +100,8 @@ const useTreeViewSelection = ({
     lastSelectedRange.current = {};
   };
   const selectRange = (event, [start, end]) => {
-    if (params.disableSelection || !params.multiSelect) {
+    const isMultiSelectEnabled = (0, _useTreeViewSelection2.selectorIsMultiSelectEnabled)(store.value);
+    if (!isMultiSelectEnabled) {
       return;
     }
     let newSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value).slice();
@@ -137,7 +133,8 @@ const useTreeViewSelection = ({
     selectRange(event, [itemId, (0, _tree.getLastNavigableItem)(store.value)]);
   };
   const selectAllNavigableItems = event => {
-    if (params.disableSelection || !params.multiSelect) {
+    const isMultiSelectEnabled = (0, _useTreeViewSelection2.selectorIsMultiSelectEnabled)(store.value);
+    if (!isMultiSelectEnabled) {
       return;
     }
     const navigableItems = (0, _tree.getAllNavigableItems)(store.value);
@@ -145,7 +142,8 @@ const useTreeViewSelection = ({
     lastSelectedRange.current = (0, _useTreeViewSelection.getLookupFromArray)(navigableItems);
   };
   const selectItemFromArrowNavigation = (event, currentItem, nextItem) => {
-    if (params.disableSelection || !params.multiSelect) {
+    const isMultiSelectEnabled = (0, _useTreeViewSelection2.selectorIsMultiSelectEnabled)(store.value);
+    if (!isMultiSelectEnabled) {
       return;
     }
     let newSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value).slice();
@@ -169,17 +167,22 @@ const useTreeViewSelection = ({
     }
     setSelectedItems(event, newSelectedItems);
   };
-  const pluginContextValue = React.useMemo(() => ({
-    selection: {
-      multiSelect: params.multiSelect,
-      checkboxSelection: params.checkboxSelection,
-      disableSelection: params.disableSelection,
-      selectionPropagation: {
-        descendants: params.selectionPropagation.descendants,
-        parents: params.selectionPropagation.parents
+  (0, _useEnhancedEffect.default)(() => {
+    store.update(prevState => (0, _extends2.default)({}, prevState, {
+      selection: {
+        rawSelectedItems: models.selectedItems.value,
+        // Only re-compute the map when the model changes.
+        selectedItemsMap: prevState.selection.rawSelectedItems === models.selectedItems.value ? prevState.selection.selectedItemsMap : (0, _useTreeViewSelection.createSelectedItemsMap)(models.selectedItems.value),
+        isEnabled: !params.disableSelection,
+        isMultiSelectEnabled: params.multiSelect,
+        isCheckboxSelectionEnabled: params.checkboxSelection,
+        selectionPropagation: {
+          descendants: params.selectionPropagation.descendants,
+          parents: params.selectionPropagation.parents
+        }
       }
-    }
-  }), [params.multiSelect, params.checkboxSelection, params.disableSelection, params.selectionPropagation.descendants, params.selectionPropagation.parents]);
+    }));
+  }, [store, models.selectedItems.value, params.multiSelect, params.checkboxSelection, params.disableSelection, params.selectionPropagation.descendants, params.selectionPropagation.parents]);
   return {
     getRootProps: () => ({
       'aria-multiselectable': params.multiSelect
@@ -194,8 +197,7 @@ const useTreeViewSelection = ({
       selectRangeFromStartToItem,
       selectRangeFromItemToEnd,
       selectItemFromArrowNavigation
-    },
-    contextValue: pluginContextValue
+    }
   };
 };
 exports.useTreeViewSelection = useTreeViewSelection;
@@ -216,16 +218,19 @@ useTreeViewSelection.getDefaultizedParams = ({
   defaultSelectedItems: params.defaultSelectedItems ?? (params.multiSelect ? DEFAULT_SELECTED_ITEMS : null),
   selectionPropagation: params.selectionPropagation ?? EMPTY_SELECTION_PROPAGATION
 });
-useTreeViewSelection.getInitialState = params => ({
-  selection: {
-    selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
-  }
-});
-useTreeViewSelection.getInitialState = params => ({
-  selection: {
-    selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
-  }
-});
+useTreeViewSelection.getInitialState = params => {
+  const rawSelectedItems = params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems;
+  return {
+    selection: {
+      rawSelectedItems,
+      selectedItemsMap: (0, _useTreeViewSelection.createSelectedItemsMap)(rawSelectedItems),
+      isEnabled: !params.disableSelection,
+      isMultiSelectEnabled: params.multiSelect,
+      isCheckboxSelectionEnabled: params.checkboxSelection,
+      selectionPropagation: params.selectionPropagation
+    }
+  };
+};
 useTreeViewSelection.params = {
   disableSelection: true,
   multiSelect: true,

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

@@ -11,10 +11,20 @@ export declare const selectorIsItemSelected: ((state: any, itemId: string) => bo
   resetResultsCount: () => void;
 } & {
   resultFunc: (resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
     selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
   }, resultFuncArgs_1: string) => boolean;
   memoizedResultFunc: ((resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
     selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
   }, resultFuncArgs_1: string) => boolean) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -29,4 +39,325 @@ export declare const selectorIsItemSelected: ((state: any, itemId: string) => bo
 } & {
   argsMemoize: typeof import("reselect").weakMapMemoize;
   memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if multi selection is enabled.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if multi selection is enabled, `false` otherwise.
+ */
+export declare const selectorIsMultiSelectEnabled: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
+    selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+  }) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
+    selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+  }) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if selection is enabled.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if selection is enabled, `false` otherwise.
+ */
+export declare const selectorIsSelectionEnabled: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
+    selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+  }) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
+    selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+  }) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if checkbox selection is enabled.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if checkbox selection is enabled, `false` otherwise.
+ */
+export declare const selectorIsCheckboxSelectionEnabled: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
+    selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+  }) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
+    selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+  }) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if selection is enabled for an item (if selection is enabled and if the item is not disabled).
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @param {string} itemId The id of the item to check.
+ * @returns {boolean} `true` if selection is enabled for the item, `false` otherwise.
+ */
+export declare const selectorIsItemSelectionEnabled: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: boolean) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: boolean) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [((state: any, itemId: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      [itemId: string]: import("../..").TreeViewItemMeta;
+    }, resultFuncArgs_1: string) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      [itemId: string]: import("../..").TreeViewItemMeta;
+    }, resultFuncArgs_1: string) => boolean) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("../useTreeViewItems").UseTreeViewItemsState<import("../../..").TreeViewDefaultItemModelProperties> & Partial<{}> & {
+      cacheKey: import("../../models").TreeViewStateCacheKey;
+    }) => {
+      [itemId: string]: import("../..").TreeViewItemMeta;
+    }) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    } & {
+      resultFunc: (resultFuncArgs_0: {
+        disabledItemsFocusable: boolean;
+        itemModelLookup: {
+          [itemId: string]: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>;
+        };
+        itemMetaLookup: {
+          [itemId: string]: import("../..").TreeViewItemMeta;
+        };
+        itemOrderedChildrenIdsLookup: {
+          [parentItemId: string]: string[];
+        };
+        itemChildrenIndexesLookup: {
+          [parentItemId: string]: {
+            [itemId: string]: number;
+          };
+        };
+        loading: boolean;
+        error: Error | null;
+      }) => {
+        [itemId: string]: import("../..").TreeViewItemMeta;
+      };
+      memoizedResultFunc: ((resultFuncArgs_0: {
+        disabledItemsFocusable: boolean;
+        itemModelLookup: {
+          [itemId: string]: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>;
+        };
+        itemMetaLookup: {
+          [itemId: string]: import("../..").TreeViewItemMeta;
+        };
+        itemOrderedChildrenIdsLookup: {
+          [parentItemId: string]: string[];
+        };
+        itemChildrenIndexesLookup: {
+          [parentItemId: string]: {
+            [itemId: string]: number;
+          };
+        };
+        loading: boolean;
+        error: Error | null;
+      }) => {
+        [itemId: string]: import("../..").TreeViewItemMeta;
+      }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+      };
+      lastResult: () => {
+        [itemId: string]: import("../..").TreeViewItemMeta;
+      };
+      dependencies: [TreeViewRootSelector<import("../useTreeViewItems").UseTreeViewItemsSignature>];
+      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;
+  }, ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      rawSelectedItems: string | string[] | null;
+      selectedItemsMap: Map<string, true>;
+      isEnabled: boolean;
+      isMultiSelectEnabled: boolean;
+      isCheckboxSelectionEnabled: boolean;
+      selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+    }) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      rawSelectedItems: string | string[] | null;
+      selectedItemsMap: Map<string, true>;
+      isEnabled: boolean;
+      isMultiSelectEnabled: boolean;
+      isCheckboxSelectionEnabled: boolean;
+      selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+    }) => boolean) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get the selection propagation rules.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {TreeViewSelectionPropagation} The selection propagation rules.
+ */
+export declare const selectorSelectionPropagationRules: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewSelection.types").UseTreeViewSelectionState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => import("../../..").TreeViewSelectionPropagation) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
+    selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+  }) => import("../../..").TreeViewSelectionPropagation;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    rawSelectedItems: string | string[] | null;
+    selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: import("../../..").TreeViewSelectionPropagation;
+  }) => import("../../..").TreeViewSelectionPropagation) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => import("../../..").TreeViewSelectionPropagation;
+  dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
 };

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.selectors.js

@@ -3,8 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.selectorIsItemSelected = void 0;
+exports.selectorSelectionPropagationRules = exports.selectorIsSelectionEnabled = exports.selectorIsMultiSelectEnabled = exports.selectorIsItemSelectionEnabled = exports.selectorIsItemSelected = exports.selectorIsCheckboxSelectionEnabled = void 0;
 var _selectors = require("../../utils/selectors");
+var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
 const selectorTreeViewSelectionState = state => state.selection;
 
 /**
@@ -12,4 +13,40 @@ const selectorTreeViewSelectionState = state => state.selection;
  * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
  * @returns {boolean} `true` if the item is selected, `false` otherwise.
  */
-const selectorIsItemSelected = exports.selectorIsItemSelected = (0, _selectors.createSelector)([selectorTreeViewSelectionState, (_, itemId) => itemId], (selectionState, itemId) => selectionState.selectedItemsMap.has(itemId));
+const selectorIsItemSelected = exports.selectorIsItemSelected = (0, _selectors.createSelector)([selectorTreeViewSelectionState, (_, itemId) => itemId], (selectionState, itemId) => selectionState.selectedItemsMap.has(itemId));
+
+/**
+ * Check if multi selection is enabled.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if multi selection is enabled, `false` otherwise.
+ */
+const selectorIsMultiSelectEnabled = exports.selectorIsMultiSelectEnabled = (0, _selectors.createSelector)([selectorTreeViewSelectionState], selectionState => selectionState.isEnabled && selectionState.isMultiSelectEnabled);
+
+/**
+ * Check if selection is enabled.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if selection is enabled, `false` otherwise.
+ */
+const selectorIsSelectionEnabled = exports.selectorIsSelectionEnabled = (0, _selectors.createSelector)([selectorTreeViewSelectionState], selectionState => selectionState.isEnabled);
+
+/**
+ * Check if checkbox selection is enabled.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {boolean} `true` if checkbox selection is enabled, `false` otherwise.
+ */
+const selectorIsCheckboxSelectionEnabled = exports.selectorIsCheckboxSelectionEnabled = (0, _selectors.createSelector)([selectorTreeViewSelectionState], selectionState => selectionState.isCheckboxSelectionEnabled);
+
+/**
+ * Check if selection is enabled for an item (if selection is enabled and if the item is not disabled).
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @param {string} itemId The id of the item to check.
+ * @returns {boolean} `true` if selection is enabled for the item, `false` otherwise.
+ */
+const selectorIsItemSelectionEnabled = exports.selectorIsItemSelectionEnabled = (0, _selectors.createSelector)([_useTreeViewItems.selectorIsItemDisabled, selectorIsSelectionEnabled], (isItemDisabled, isSelectionEnabled) => isSelectionEnabled && !isItemDisabled);
+
+/**
+ * Get the selection propagation rules.
+ * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
+ * @returns {TreeViewSelectionPropagation} The selection propagation rules.
+ */
+const selectorSelectionPropagationRules = exports.selectorSelectionPropagationRules = (0, _selectors.createSelector)([selectorTreeViewSelectionState], selectionState => selectionState.selectionPropagation);

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

@@ -115,18 +115,19 @@ export interface UseTreeViewSelectionParameters<Multiple extends boolean | undef
 export type UseTreeViewSelectionDefaultizedParameters<Multiple extends boolean> = DefaultizedProps<UseTreeViewSelectionParameters<Multiple>, 'disableSelection' | 'defaultSelectedItems' | 'multiSelect' | 'checkboxSelection' | 'selectionPropagation'>;
 export interface UseTreeViewSelectionState {
   selection: {
+    rawSelectedItems: TreeViewSelectionValue<boolean>;
     selectedItemsMap: Map<string, true>;
+    isEnabled: boolean;
+    isMultiSelectEnabled: boolean;
+    isCheckboxSelectionEnabled: boolean;
+    selectionPropagation: TreeViewSelectionPropagation;
   };
 }
-interface UseTreeViewSelectionContextValue {
-  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];

package/internals/utils/selectors.d.ts

@@ -3,7 +3,7 @@ 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> = <TSignatures extends [TSignature]>(state: TreeViewState<TSignatures>) => TSignature['state'][keyof TSignature['state']];
+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.
  */