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

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -1,28 +1,30 @@
-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 = ({
+"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 = ({
   store,
   params,
   models
 }) => {
   const lastSelectedItem = React.useRef(null);
   const lastSelectedRange = React.useRef({});
-  useEnhancedEffect(() => {
-    store.update(prevState => _extends({}, prevState, {
-      selection: {
-        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 = propagateSelection({
+    const isMultiSelectEnabled = (0, _useTreeViewSelection2.selectorIsMultiSelectEnabled)(store.value);
+    if (isMultiSelectEnabled && (params.selectionPropagation.descendants || params.selectionPropagation.parents)) {
+      cleanModel = (0, _useTreeViewSelection.propagateSelection)({
         store,
         selectionPropagation: params.selectionPropagation,
         newModel: newModel,
@@ -33,8 +35,8 @@ export const useTreeViewSelection = ({
       cleanModel = newModel;
     }
     if (params.onItemSelectionToggle) {
-      if (params.multiSelect) {
-        const changes = getAddedAndRemovedItems({
+      if (isMultiSelectEnabled) {
+        const changes = (0, _useTreeViewSelection.getAddedAndRemovedItems)({
           store,
           newModel: cleanModel,
           oldModel: models.selectedItems.value
@@ -61,19 +63,20 @@ export const useTreeViewSelection = ({
     }
     models.selectedItems.setControlledValue(cleanModel);
   };
-  const selectItem = ({
-    event,
+  const setItemSelection = ({
     itemId,
+    event = null,
     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 = convertSelectedItemsToArray(models.selectedItems.value);
-      const isSelectedBefore = selectorIsItemSelected(store.value, itemId);
+      const cleanSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value);
+      const isSelectedBefore = (0, _useTreeViewSelection2.selectorIsItemSelected)(store.value, itemId);
       if (isSelectedBefore && (shouldBeSelected === false || shouldBeSelected == null)) {
         newSelected = cleanSelectedItems.filter(id => id !== itemId);
       } else if (!isSelectedBefore && (shouldBeSelected === true || shouldBeSelected == null)) {
@@ -83,10 +86,10 @@ export const useTreeViewSelection = ({
       }
     } else {
       // eslint-disable-next-line no-lonely-if
-      if (shouldBeSelected === false || shouldBeSelected == null && selectorIsItemSelected(store.value, itemId)) {
-        newSelected = params.multiSelect ? [] : null;
+      if (shouldBeSelected === false || shouldBeSelected == null && (0, _useTreeViewSelection2.selectorIsItemSelected)(store.value, itemId)) {
+        newSelected = isMultiSelectEnabled ? [] : null;
       } else {
-        newSelected = params.multiSelect ? [itemId] : itemId;
+        newSelected = isMultiSelectEnabled ? [itemId] : itemId;
       }
     }
     setSelectedItems(event, newSelected,
@@ -97,10 +100,11 @@ export 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 = convertSelectedItemsToArray(models.selectedItems.value).slice();
+    let newSelectedItems = (0, _useTreeViewSelection.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
@@ -109,38 +113,40 @@ export const useTreeViewSelection = ({
     }
 
     // Add to the model the items that are part of the new range and not already part of the model.
-    const selectedItemsLookup = getLookupFromArray(newSelectedItems);
-    const range = getNonDisabledItemsInRange(store.value, start, end);
+    const selectedItemsLookup = (0, _useTreeViewSelection.getLookupFromArray)(newSelectedItems);
+    const range = (0, _tree.getNonDisabledItemsInRange)(store.value, start, end);
     const itemsToAddToModel = range.filter(id => !selectedItemsLookup[id]);
     newSelectedItems = newSelectedItems.concat(itemsToAddToModel);
     setSelectedItems(event, newSelectedItems);
-    lastSelectedRange.current = getLookupFromArray(range);
+    lastSelectedRange.current = (0, _useTreeViewSelection.getLookupFromArray)(range);
   };
   const expandSelectionRange = (event, itemId) => {
     if (lastSelectedItem.current != null) {
-      const [start, end] = findOrderInTremauxTree(store.value, itemId, lastSelectedItem.current);
+      const [start, end] = (0, _tree.findOrderInTremauxTree)(store.value, itemId, lastSelectedItem.current);
       selectRange(event, [start, end]);
     }
   };
   const selectRangeFromStartToItem = (event, itemId) => {
-    selectRange(event, [getFirstNavigableItem(store.value), itemId]);
+    selectRange(event, [(0, _tree.getFirstNavigableItem)(store.value), itemId]);
   };
   const selectRangeFromItemToEnd = (event, itemId) => {
-    selectRange(event, [itemId, getLastNavigableItem(store.value)]);
+    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 = getAllNavigableItems(store.value);
+    const navigableItems = (0, _tree.getAllNavigableItems)(store.value);
     setSelectedItems(event, navigableItems);
-    lastSelectedRange.current = getLookupFromArray(navigableItems);
+    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 = convertSelectedItemsToArray(models.selectedItems.value).slice();
+    let newSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value).slice();
     if (Object.keys(lastSelectedRange.current).length === 0) {
       newSelectedItems.push(nextItem);
       lastSelectedRange.current = {
@@ -161,36 +167,41 @@ export 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
     }),
     publicAPI: {
-      selectItem
+      setItemSelection
     },
     instance: {
-      selectItem,
+      setItemSelection,
       selectAllNavigableItems,
       expandSelectionRange,
       selectRangeFromStartToItem,
       selectRangeFromItemToEnd,
       selectItemFromArrowNavigation
-    },
-    contextValue: pluginContextValue
+    }
   };
 };
-useTreeViewSelection.itemPlugin = useTreeViewSelectionItemPlugin;
+exports.useTreeViewSelection = useTreeViewSelection;
+useTreeViewSelection.itemPlugin = _useTreeViewSelection3.useTreeViewSelectionItemPlugin;
 useTreeViewSelection.models = {
   selectedItems: {
     getDefaultValue: params => params.defaultSelectedItems
@@ -200,23 +211,26 @@ const DEFAULT_SELECTED_ITEMS = [];
 const EMPTY_SELECTION_PROPAGATION = {};
 useTreeViewSelection.getDefaultizedParams = ({
   params
-}) => _extends({}, params, {
+}) => (0, _extends2.default)({}, params, {
   disableSelection: params.disableSelection ?? false,
   multiSelect: params.multiSelect ?? false,
   checkboxSelection: params.checkboxSelection ?? false,
   defaultSelectedItems: params.defaultSelectedItems ?? (params.multiSelect ? DEFAULT_SELECTED_ITEMS : null),
   selectionPropagation: params.selectionPropagation ?? EMPTY_SELECTION_PROPAGATION
 });
-useTreeViewSelection.getInitialState = params => ({
-  selection: {
-    selectedItemsMap: createSelectedItemsMap(params.selectedItems === undefined ? params.defaultSelectedItems : params.selectedItems)
-  }
-});
-useTreeViewSelection.getInitialState = params => ({
-  selection: {
-    selectedItemsMap: 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

@@ -1,32 +1,363 @@
-import { TreeViewRootSelector } from '../../utils/selectors';
-import { UseTreeViewSelectionSignature } from './useTreeViewSelection.types';
+import { TreeViewRootSelector } from "../../utils/selectors.js";
+import { UseTreeViewSelectionSignature } from "./useTreeViewSelection.types.js";
 /**
  * Check if an item is selected.
  * @param {TreeViewState<[UseTreeViewSelectionSignature]>} state The state of the tree view.
  * @returns {boolean} `true` if the item is selected, `false` otherwise.
  */
 export declare const selectorIsItemSelected: ((state: any, itemId: string) => 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;
+  }, 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;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelector<UseTreeViewSelectionSignature>, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  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: {
-        selectedItemsMap: Map<string, true>;
+      [itemId: string]: import("../..").TreeViewItemMeta;
     }, resultFuncArgs_1: string) => boolean;
     memoizedResultFunc: ((resultFuncArgs_0: {
-        selectedItemsMap: Map<string, true>;
+      [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>, (_: any, itemId: string) => string];
+    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;
+};