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

package/node/internals/plugins/useTreeViewLabel/useTreeViewLabel.itemPlugin.js

@@ -7,30 +7,38 @@ Object.defineProperty(exports, "__esModule", {
 exports.useTreeViewLabelItemPlugin = void 0;
 var React = _interopRequireWildcard(require("react"));
 var _TreeViewProvider = require("../../TreeViewProvider");
+var _useSelector = require("../../hooks/useSelector");
+var _useTreeViewLabel = require("./useTreeViewLabel.selectors");
 const useTreeViewLabelItemPlugin = ({
   props
 }) => {
   const {
-    instance
+    store,
+    label: {
+      isItemEditable
+    }
   } = (0, _TreeViewProvider.useTreeViewContext)();
   const {
     label,
     itemId
   } = props;
   const [labelInputValue, setLabelInputValue] = React.useState(label);
-  const isItemBeingEdited = instance.isItemBeingEdited(itemId);
+  const editable = (0, _useSelector.useSelector)(store, _useTreeViewLabel.selectorIsItemEditable, {
+    itemId,
+    isItemEditable
+  });
+  const editing = (0, _useSelector.useSelector)(store, _useTreeViewLabel.selectorIsItemBeingEdited, itemId);
   React.useEffect(() => {
-    if (!isItemBeingEdited) {
+    if (!editing) {
       setLabelInputValue(label);
     }
-  }, [isItemBeingEdited, label]);
+  }, [editing, label]);
   return {
     propsEnhancers: {
       labelInput: ({
         externalEventHandlers,
         interactions
       }) => {
-        const editable = instance.isItemEditable(itemId);
         if (!editable) {
           return {};
         }

package/node/internals/plugins/useTreeViewLabel/useTreeViewLabel.js

@@ -11,41 +11,26 @@ var React = _interopRequireWildcard(require("react"));
 var _warning = require("@mui/x-internals/warning");
 var _useTreeViewLabel = require("./useTreeViewLabel.itemPlugin");
 const useTreeViewLabel = ({
-  instance,
-  state,
-  setState,
+  store,
   params
 }) => {
-  const editedItemRef = React.useRef(state.editedItemId);
-  const isItemBeingEditedRef = itemId => editedItemRef.current === itemId;
   const setEditedItemId = editedItemId => {
-    setState(prevState => (0, _extends2.default)({}, prevState, {
-      editedItemId
+    store.update(prevState => (0, _extends2.default)({}, prevState, {
+      label: {
+        editedItemId
+      }
     }));
-    editedItemRef.current = editedItemId;
-  };
-  const isItemBeingEdited = itemId => itemId === state.editedItemId;
-  const isTreeViewEditable = Boolean(params.isItemEditable);
-  const isItemEditable = itemId => {
-    if (itemId == null || !isTreeViewEditable) {
-      return false;
-    }
-    const item = instance.getItem(itemId);
-    if (!item) {
-      return false;
-    }
-    return typeof params.isItemEditable === 'function' ? params.isItemEditable(item) : Boolean(params.isItemEditable);
   };
   const updateItemLabel = (itemId, label) => {
     if (!label) {
       throw new Error(['MUI X: The Tree View component requires all items to have a `label` property.', 'The label of an item cannot be empty.', itemId].join('\n'));
     }
-    setState(prevState => {
-      const item = prevState.items.itemMetaMap[itemId];
+    store.update(prevState => {
+      const item = prevState.items.itemMetaLookup[itemId];
       if (item.label !== label) {
         return (0, _extends2.default)({}, prevState, {
           items: (0, _extends2.default)({}, prevState.items, {
-            itemMetaMap: (0, _extends2.default)({}, prevState.items.itemMetaMap, {
+            itemMetaLookup: (0, _extends2.default)({}, prevState.items.itemMetaLookup, {
               [itemId]: (0, _extends2.default)({}, item, {
                 label
               })
@@ -59,18 +44,20 @@ const useTreeViewLabel = ({
       params.onItemLabelChange(itemId, label);
     }
   };
+  const pluginContextValue = React.useMemo(() => ({
+    label: {
+      isItemEditable: params.isItemEditable
+    }
+  }), [params.isItemEditable]);
   return {
     instance: {
       setEditedItemId,
-      isItemBeingEdited,
-      updateItemLabel,
-      isItemEditable,
-      isTreeViewEditable,
-      isItemBeingEditedRef
+      updateItemLabel
     },
     publicAPI: {
       updateItemLabel
-    }
+    },
+    contextValue: pluginContextValue
   };
 };
 exports.useTreeViewLabel = useTreeViewLabel;
@@ -90,7 +77,9 @@ useTreeViewLabel.getDefaultizedParams = ({
   });
 };
 useTreeViewLabel.getInitialState = () => ({
-  editedItemId: null
+  label: {
+    editedItemId: null
+  }
 });
 useTreeViewLabel.params = {
   onItemLabelChange: true,

package/node/internals/plugins/useTreeViewLabel/useTreeViewLabel.selectors.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectorIsItemEditable = exports.selectorIsItemBeingEdited = void 0;
+var _selectors = require("../../utils/selectors");
+var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
+const selectorTreeViewLabelState = state => state.label;
+
+/**
+ * Check if an item is editable.
+ * @param {TreeViewState<[UseTreeViewItemsSignature]>} state The state of the tree view.
+ * @param {object} params The parameters.
+ * @param {TreeViewItemId} params.itemId The id of the item to check.
+ * @param {((item: any) => boolean) | boolean} params.isItemEditable The function to determine if an item is editable.
+ * @returns {boolean} `true` if the item is editable, `false` otherwise.
+ */
+const selectorIsItemEditable = exports.selectorIsItemEditable = (0, _selectors.createSelector)([(_, args) => args, (state, args) => (0, _useTreeViewItems.selectorItemModel)(state, args.itemId)], (args, itemModel) => {
+  if (!itemModel || !args.isItemEditable) {
+    return false;
+  }
+  return typeof args.isItemEditable === 'function' ? args.isItemEditable(itemModel) : true;
+});
+
+/**
+ * Check if an item is being edited.
+ * @param {TreeViewState<[UseTreeViewLabelSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to check.
+ * @returns {boolean} `true` if the item is being edited, `false` otherwise.
+ */
+const selectorIsItemBeingEdited = exports.selectorIsItemBeingEdited = (0, _selectors.createSelector)([selectorTreeViewLabelState, (_, itemId) => itemId], (labelState, itemId) => labelState.editedItemId === itemId);

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

@@ -0,0 +1,96 @@
+"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");
+function getCheckboxStatus({
+  itemId,
+  store,
+  selectionPropagation,
+  selected
+}) {
+  if (selected) {
+    return {
+      indeterminate: false,
+      checked: true
+    };
+  }
+  const children = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId);
+  if (children.length === 0) {
+    return {
+      indeterminate: false,
+      checked: false
+    };
+  }
+  let hasSelectedDescendant = false;
+  let hasUnSelectedDescendant = false;
+  const traverseDescendants = itemToTraverseId => {
+    if (itemToTraverseId !== itemId) {
+      if ((0, _useTreeViewSelection.selectorIsItemSelected)(store.value, itemToTraverseId)) {
+        hasSelectedDescendant = true;
+      } else {
+        hasUnSelectedDescendant = true;
+      }
+    }
+    (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemToTraverseId).forEach(traverseDescendants);
+  };
+  traverseDescendants(itemId);
+  return {
+    indeterminate: hasSelectedDescendant && hasUnSelectedDescendant || !hasUnSelectedDescendant && !selected,
+    checked: selectionPropagation.parents ? hasSelectedDescendant : selected
+  };
+}
+const useTreeViewSelectionItemPlugin = ({
+  props
+}) => {
+  const {
+    itemId
+  } = props;
+  const {
+    store,
+    selection: {
+      disableSelection,
+      checkboxSelection,
+      selectionPropagation
+    }
+  } = (0, _TreeViewProvider.useTreeViewContext)();
+  return {
+    propsEnhancers: {
+      checkbox: ({
+        externalEventHandlers,
+        interactions,
+        status
+      }) => {
+        const handleChange = event => {
+          externalEventHandlers.onChange?.(event);
+          if (event.defaultMuiPrevented) {
+            return;
+          }
+          if (disableSelection || status.disabled) {
+            return;
+          }
+          interactions.handleCheckboxSelection(event);
+        };
+        const checkboxStatus = getCheckboxStatus({
+          store,
+          itemId,
+          selectionPropagation,
+          selected: status.selected
+        });
+        return (0, _extends2.default)({
+          visible: checkboxSelection,
+          disabled: disableSelection || status.disabled,
+          tabIndex: -1,
+          onChange: handleChange
+        }, checkboxStatus);
+      }
+    }
+  };
+};
+exports.useTreeViewSelectionItemPlugin = useTreeViewSelectionItemPlugin;

package/node/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -8,52 +8,67 @@ Object.defineProperty(exports, "__esModule", {
 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 = ({
-  instance,
+  store,
   params,
   models
 }) => {
   const lastSelectedItem = React.useRef(null);
   const lastSelectedRange = React.useRef({});
-  const selectedItemsMap = React.useMemo(() => {
-    const temp = new Map();
-    if (Array.isArray(models.selectedItems.value)) {
-      models.selectedItems.value.forEach(id => {
-        temp.set(id, true);
+  (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)) {
+      cleanModel = (0, _useTreeViewSelection.propagateSelection)({
+        store,
+        selectionPropagation: params.selectionPropagation,
+        newModel: newModel,
+        oldModel: models.selectedItems.value,
+        additionalItemsToPropagate
       });
-    } else if (models.selectedItems.value != null) {
-      temp.set(models.selectedItems.value, true);
+    } else {
+      cleanModel = newModel;
     }
-    return temp;
-  }, [models.selectedItems.value]);
-  const setSelectedItems = (event, newSelectedItems) => {
     if (params.onItemSelectionToggle) {
       if (params.multiSelect) {
-        const addedItems = newSelectedItems.filter(itemId => !instance.isItemSelected(itemId));
-        const removedItems = models.selectedItems.value.filter(itemId => !newSelectedItems.includes(itemId));
-        addedItems.forEach(itemId => {
-          params.onItemSelectionToggle(event, itemId, true);
-        });
-        removedItems.forEach(itemId => {
-          params.onItemSelectionToggle(event, itemId, false);
+        const changes = (0, _useTreeViewSelection.getAddedAndRemovedItems)({
+          store,
+          newModel: cleanModel,
+          oldModel: models.selectedItems.value
         });
-      } else if (newSelectedItems !== models.selectedItems.value) {
+        if (params.onItemSelectionToggle) {
+          changes.added.forEach(itemId => {
+            params.onItemSelectionToggle(event, itemId, true);
+          });
+          changes.removed.forEach(itemId => {
+            params.onItemSelectionToggle(event, itemId, false);
+          });
+        }
+      } else if (params.onItemSelectionToggle && cleanModel !== models.selectedItems.value) {
         if (models.selectedItems.value != null) {
           params.onItemSelectionToggle(event, models.selectedItems.value, false);
         }
-        if (newSelectedItems != null) {
-          params.onItemSelectionToggle(event, newSelectedItems, true);
+        if (cleanModel != null) {
+          params.onItemSelectionToggle(event, cleanModel, true);
         }
       }
     }
     if (params.onSelectedItemsChange) {
-      params.onSelectedItemsChange(event, newSelectedItems);
+      params.onSelectedItemsChange(event, cleanModel);
     }
-    models.selectedItems.setControlledValue(newSelectedItems);
+    models.selectedItems.setControlledValue(cleanModel);
   };
-  const isItemSelected = itemId => selectedItemsMap.has(itemId);
   const selectItem = ({
     event,
     itemId,
@@ -66,7 +81,7 @@ const useTreeViewSelection = ({
     let newSelected;
     if (keepExistingSelection) {
       const cleanSelectedItems = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value);
-      const isSelectedBefore = instance.isItemSelected(itemId);
+      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)) {
@@ -76,13 +91,16 @@ const useTreeViewSelection = ({
       }
     } else {
       // eslint-disable-next-line no-lonely-if
-      if (shouldBeSelected === false || shouldBeSelected == null && instance.isItemSelected(itemId)) {
+      if (shouldBeSelected === false || shouldBeSelected == null && (0, _useTreeViewSelection2.selectorIsItemSelected)(store.value, itemId)) {
         newSelected = params.multiSelect ? [] : null;
       } else {
         newSelected = params.multiSelect ? [itemId] : itemId;
       }
     }
-    setSelectedItems(event, newSelected);
+    setSelectedItems(event, newSelected,
+    // If shouldBeSelected === selectorIsItemSelected(store, itemId), we still want to propagate the select.
+    // This is useful when the element is in an indeterminate state.
+    [itemId]);
     lastSelectedItem.current = itemId;
     lastSelectedRange.current = {};
   };
@@ -100,7 +118,7 @@ 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)(instance, start, end);
+    const range = (0, _tree.getNonDisabledItemsInRange)(store.value, start, end);
     const itemsToAddToModel = range.filter(id => !selectedItemsLookup[id]);
     newSelectedItems = newSelectedItems.concat(itemsToAddToModel);
     setSelectedItems(event, newSelectedItems);
@@ -108,21 +126,21 @@ const useTreeViewSelection = ({
   };
   const expandSelectionRange = (event, itemId) => {
     if (lastSelectedItem.current != null) {
-      const [start, end] = (0, _tree.findOrderInTremauxTree)(instance, itemId, lastSelectedItem.current);
+      const [start, end] = (0, _tree.findOrderInTremauxTree)(store.value, itemId, lastSelectedItem.current);
       selectRange(event, [start, end]);
     }
   };
   const selectRangeFromStartToItem = (event, itemId) => {
-    selectRange(event, [(0, _tree.getFirstNavigableItem)(instance), itemId]);
+    selectRange(event, [(0, _tree.getFirstNavigableItem)(store.value), itemId]);
   };
   const selectRangeFromItemToEnd = (event, itemId) => {
-    selectRange(event, [itemId, (0, _tree.getLastNavigableItem)(instance)]);
+    selectRange(event, [itemId, (0, _tree.getLastNavigableItem)(store.value)]);
   };
   const selectAllNavigableItems = event => {
     if (params.disableSelection || !params.multiSelect) {
       return;
     }
-    const navigableItems = (0, _tree.getAllNavigableItems)(instance);
+    const navigableItems = (0, _tree.getAllNavigableItems)(store.value);
     setSelectedItems(event, navigableItems);
     lastSelectedRange.current = (0, _useTreeViewSelection.getLookupFromArray)(navigableItems);
   };
@@ -151,6 +169,17 @@ 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
+      }
+    }
+  }), [params.multiSelect, params.checkboxSelection, params.disableSelection, params.selectionPropagation.descendants, params.selectionPropagation.parents]);
   return {
     getRootProps: () => ({
       'aria-multiselectable': params.multiSelect
@@ -159,7 +188,6 @@ const useTreeViewSelection = ({
       selectItem
     },
     instance: {
-      isItemSelected,
       selectItem,
       selectAllNavigableItems,
       expandSelectionRange,
@@ -167,29 +195,36 @@ const useTreeViewSelection = ({
       selectRangeFromItemToEnd,
       selectItemFromArrowNavigation
     },
-    contextValue: {
-      selection: {
-        multiSelect: params.multiSelect,
-        checkboxSelection: params.checkboxSelection,
-        disableSelection: params.disableSelection
-      }
-    }
+    contextValue: pluginContextValue
   };
 };
 exports.useTreeViewSelection = useTreeViewSelection;
+useTreeViewSelection.itemPlugin = _useTreeViewSelection3.useTreeViewSelectionItemPlugin;
 useTreeViewSelection.models = {
   selectedItems: {
     getDefaultValue: params => params.defaultSelectedItems
   }
 };
 const DEFAULT_SELECTED_ITEMS = [];
+const EMPTY_SELECTION_PROPAGATION = {};
 useTreeViewSelection.getDefaultizedParams = ({
   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)
+  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.params = {
   disableSelection: true,
@@ -198,5 +233,6 @@ useTreeViewSelection.params = {
   defaultSelectedItems: true,
   selectedItems: true,
   onSelectedItemsChange: true,
-  onItemSelectionToggle: true
+  onItemSelectionToggle: true,
+  selectionPropagation: true
 };

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectorIsItemSelected = void 0;
+var _selectors = require("../../utils/selectors");
+const selectorTreeViewSelectionState = state => state.selection;
+
+/**
+ * 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.
+ */
+const selectorIsItemSelected = exports.selectorIsItemSelected = (0, _selectors.createSelector)([selectorTreeViewSelectionState, (_, itemId) => itemId], (selectionState, itemId) => selectionState.selectedItemsMap.has(itemId));

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

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getLookupFromArray = exports.convertSelectedItemsToArray = void 0;
+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.
@@ -19,6 +21,14 @@ const convertSelectedItemsToArray = model => {
   return [];
 };
 exports.convertSelectedItemsToArray = convertSelectedItemsToArray;
+const createSelectedItemsMap = selectedItems => {
+  const selectedItemsMap = new Map();
+  convertSelectedItemsToArray(selectedItems).forEach(id => {
+    selectedItemsMap.set(id, true);
+  });
+  return selectedItemsMap;
+};
+exports.createSelectedItemsMap = createSelectedItemsMap;
 const getLookupFromArray = array => {
   const lookup = {};
   array.forEach(itemId => {
@@ -26,4 +36,101 @@ const getLookupFromArray = array => {
   });
   return lookup;
 };
-exports.getLookupFromArray = getLookupFromArray;
+exports.getLookupFromArray = getLookupFromArray;
+const getAddedAndRemovedItems = ({
+  store,
+  oldModel,
+  newModel
+}) => {
+  const newModelLookup = createSelectedItemsMap(newModel);
+  return {
+    added: newModel.filter(itemId => !(0, _useTreeViewSelection.selectorIsItemSelected)(store.value, itemId)),
+    removed: oldModel.filter(itemId => !newModelLookup.has(itemId))
+  };
+};
+exports.getAddedAndRemovedItems = getAddedAndRemovedItems;
+const propagateSelection = ({
+  store,
+  selectionPropagation,
+  newModel,
+  oldModel,
+  additionalItemsToPropagate
+}) => {
+  if (!selectionPropagation.descendants && !selectionPropagation.parents) {
+    return newModel;
+  }
+  let shouldRegenerateModel = false;
+  const newModelLookup = getLookupFromArray(newModel);
+  const changes = getAddedAndRemovedItems({
+    store,
+    newModel,
+    oldModel
+  });
+  additionalItemsToPropagate?.forEach(itemId => {
+    if (newModelLookup[itemId]) {
+      if (!changes.added.includes(itemId)) {
+        changes.added.push(itemId);
+      }
+    } else if (!changes.removed.includes(itemId)) {
+      changes.removed.push(itemId);
+    }
+  });
+  changes.added.forEach(addedItemId => {
+    if (selectionPropagation.descendants) {
+      const selectDescendants = itemId => {
+        if (itemId !== addedItemId) {
+          shouldRegenerateModel = true;
+          newModelLookup[itemId] = true;
+        }
+        (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId).forEach(selectDescendants);
+      };
+      selectDescendants(addedItemId);
+    }
+    if (selectionPropagation.parents) {
+      const checkAllDescendantsSelected = itemId => {
+        if (!newModelLookup[itemId]) {
+          return false;
+        }
+        const children = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId);
+        return children.every(checkAllDescendantsSelected);
+      };
+      const selectParents = itemId => {
+        const parentId = (0, _useTreeViewItems.selectorItemParentId)(store.value, itemId);
+        if (parentId == null) {
+          return;
+        }
+        const siblings = (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, parentId);
+        if (siblings.every(checkAllDescendantsSelected)) {
+          shouldRegenerateModel = true;
+          newModelLookup[parentId] = true;
+          selectParents(parentId);
+        }
+      };
+      selectParents(addedItemId);
+    }
+  });
+  changes.removed.forEach(removedItemId => {
+    if (selectionPropagation.parents) {
+      let parentId = (0, _useTreeViewItems.selectorItemParentId)(store.value, removedItemId);
+      while (parentId != null) {
+        if (newModelLookup[parentId]) {
+          shouldRegenerateModel = true;
+          delete newModelLookup[parentId];
+        }
+        parentId = (0, _useTreeViewItems.selectorItemParentId)(store.value, parentId);
+      }
+    }
+    if (selectionPropagation.descendants) {
+      const deSelectDescendants = itemId => {
+        if (itemId !== removedItemId) {
+          shouldRegenerateModel = true;
+          delete newModelLookup[itemId];
+        }
+        (0, _useTreeViewItems.selectorItemOrderedChildrenIds)(store.value, itemId).forEach(deSelectDescendants);
+      };
+      deSelectDescendants(removedItemId);
+    }
+  });
+  return shouldRegenerateModel ? Object.keys(newModelLookup) : newModel;
+};
+exports.propagateSelection = propagateSelection;