@geotab/zenith 3.17.0-beta.0 → 3.17.0-beta.2

package/dist/table/selectable/useSelectableRows.js

@@ -88,6 +88,7 @@ const getCurrentPageSelection_1 = require("./utils/getCurrentPageSelection");
 const useDragSelection_1 = require("./useDragSelection");
 const getDragSelectionRows_1 = require("./utils/getDragSelectionRows");
 const showMoreRow_1 = require("../../commonHelpers/showMoreRow");
+const groupExclusions_1 = require("./utils/groupExclusions");
 const getEmptySelection = () => ({
   all: false,
   selected: []
@@ -98,13 +99,14 @@ exports.isAllSelection = isAllSelection;
 exports.SelectableWrapperName = "Selectable";
 // Infinite scroll has no pages, so the header checkbox always means "select all" (never current page).
 const resolveCheckboxEmitsCurrentPage = (isInfinite, checkboxSelectsCurrentPage, turnOffSelectAll) => isInfinite ? false : checkboxSelectsCurrentPage !== null && checkboxSelectsCurrentPage !== void 0 ? checkboxSelectsCurrentPage : turnOffSelectAll;
-const getSelectionMenuState = (allSelected, selections, pageState) => allSelected ? selections.size === 0 ? interfaces_1.SelectionState.All : interfaces_1.SelectionState.Partial : pageState;
 const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMode, selectable, isInfinite = false, gridRef, expandedRows) => {
   var _a;
   const {
     translate
   } = (0, useLanguage_1.useLanguage)();
-  const selections = (0, react_1.useMemo)(() => (0, getSelection_1.getSelections)(selectable === null || selectable === void 0 ? void 0 : selectable.selection), [selectable === null || selectable === void 0 ? void 0 : selectable.selection]);
+  const previousDatasetId = (0, react_1.useRef)(selectable === null || selectable === void 0 ? void 0 : selectable.selectionDatasetId);
+  const datasetWasReplaced = (selectable === null || selectable === void 0 ? void 0 : selectable.selectionDatasetId) !== undefined && previousDatasetId.current !== undefined && selectable.selectionDatasetId !== previousDatasetId.current;
+  const appliedSelections = (0, react_1.useMemo)(() => (0, getSelection_1.getSelections)(selectable === null || selectable === void 0 ? void 0 : selectable.selection), [selectable === null || selectable === void 0 ? void 0 : selectable.selection]);
   const [state, setState] = (0, react_1.useState)(interfaces_1.SelectionState.None);
   const checkboxVisible = (0, react_1.useMemo)(() => {
     const base = (selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible) ? selectable.checkboxVisible : (selectable === null || selectable === void 0 ? void 0 : selectable.strategy) !== "nested" ? (_, isNested) => !isNested : () => true;
@@ -120,16 +122,19 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
     }
     if (selectable === null || selectable === void 0 ? void 0 : selectable.selectionLimit) {
       const limit = selectable.selectionLimit;
-      return entity => selections.size >= limit && !selections.has(entity.id);
+      return entity => appliedSelections.size >= limit && !appliedSelections.has(entity.id);
     }
     return () => false;
-  }, [selectable, selections]);
+  }, [selectable, appliedSelections]);
   // `checkRow` and `getCurrentPageSelection` read callbacks off `selectable`, so hand them the
   // wrapped ones to apply the same exclusions.
   const wrappedSelectable = (0, react_1.useMemo)(() => selectable ? Object.assign(Object.assign({}, selectable), {
     checkboxVisible,
     checkboxDisabled
   }) : undefined, [selectable, checkboxVisible, checkboxDisabled]);
+  const resolvedSelection = (0, react_1.useMemo)(() => (0, groupExclusions_1.resolveGroupExclusions)(entities, wrappedSelectable, datasetWasReplaced), [datasetWasReplaced, entities, wrappedSelectable]);
+  const selections = (0, react_1.useMemo)(() => (0, getSelection_1.getSelections)(resolvedSelection), [resolvedSelection]);
+  const excludedGroupIds = (0, react_1.useMemo)(() => new Set((selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) && selectable.strategy === "nested" && (resolvedSelection === null || resolvedSelection === void 0 ? void 0 : resolvedSelection.all) ? resolvedSelection.excludedGroupIds : []), [selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions, selectable === null || selectable === void 0 ? void 0 : selectable.strategy, resolvedSelection === null || resolvedSelection === void 0 ? void 0 : resolvedSelection.all, resolvedSelection === null || resolvedSelection === void 0 ? void 0 : resolvedSelection.excludedGroupIds]);
   const checkboxPlaceholder = (0, react_1.useMemo)(() => {
     if ((selectable === null || selectable === void 0 ? void 0 : selectable.checkboxPlaceholder) !== undefined) {
       return selectable.checkboxPlaceholder;
@@ -144,21 +149,21 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
     var _a;
     return (0, exports.isAllSelection)((_a = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _a === void 0 ? void 0 : _a.all, selections.size, selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions);
   }, [(_a = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _a === void 0 ? void 0 : _a.all, selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions, selections.size]);
-  const selectableState = (0, react_1.useMemo)(() => (0, calculateSelectionState_1.calculateSelectionState)(entities, selections, isAllSelected, checkboxVisible, checkboxDisabled, selectable === null || selectable === void 0 ? void 0 : selectable.strategy), [checkboxDisabled, checkboxVisible, entities, isAllSelected, selections, selectable === null || selectable === void 0 ? void 0 : selectable.strategy]);
-  const selectionMenuState = getSelectionMenuState(isAllSelected, selections, selectableState);
+  const selectableState = (0, react_1.useMemo)(() => (0, calculateSelectionState_1.calculateSelectionState)(entities, new Set([...selections, ...excludedGroupIds]), isAllSelected, checkboxVisible, checkboxDisabled, selectable === null || selectable === void 0 ? void 0 : selectable.strategy), [checkboxDisabled, checkboxVisible, entities, isAllSelected, selections, excludedGroupIds, selectable === null || selectable === void 0 ? void 0 : selectable.strategy]);
   const firstColumnId = (0, react_1.useMemo)(() => columns.length > 0 ? columns[0].id : null, [columns]);
   (0, react_1.useEffect)(() => {
     if (selectable && selectable.selection) {
-      const newSelections = new Set(selectable.selection.selected);
-      const newState = (0, calculateSelectionState_1.calculateSelectionState)(entities, newSelections, isAllSelected, checkboxVisible, checkboxDisabled, selectable.strategy);
-      setState(newState);
+      setState(selectableState);
     }
-  }, [checkboxDisabled, checkboxVisible, entities, selectable, setSelectMode, selectable === null || selectable === void 0 ? void 0 : selectable.strategy, isAllSelected]);
+  }, [selectable, selectableState]);
   const getNewSelection = (0, react_1.useCallback)((id, checked) => {
     if (isAllSelected && !(selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions)) {
       const included = (0, getCurrentPageSelection_1.getCurrentPageSelection)(entities, wrappedSelectable);
       (0, checkRow_1.checkRow)(included, wrappedSelectable, entities, id, checked);
-      return included;
+      return {
+        selected: included,
+        groups: new Set()
+      };
     }
     if (isAllSelected) {
       // MYG-142234: `selections` holds the ids excluded from the "all" selection.
@@ -166,22 +171,29 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
       // exclusion set - it must never be rebuilt from `entities` (the current page),
       // otherwise every other page's rows would silently fall out of the selection.
       const excluded = new Set(selections);
-      (0, checkRow_1.checkRow)(excluded, wrappedSelectable, entities, id, !checked);
-      return excluded;
+      const groups = new Set(excludedGroupIds);
+      (0, groupExclusions_1.checkExcludedRow)(excluded, groups, wrappedSelectable, entities, id, checked);
+      return {
+        selected: excluded,
+        groups
+      };
     }
     (0, checkRow_1.checkRow)(selections, wrappedSelectable, entities, id, checked);
-    return selections;
-  }, [entities, selectable, wrappedSelectable, selections, isAllSelected]);
+    return {
+      selected: selections,
+      groups: new Set()
+    };
+  }, [entities, selectable, wrappedSelectable, selections, excludedGroupIds, isAllSelected]);
   const onSelectListener = (0, react_1.useCallback)((id, checked) => {
     const wasAllSelected = !!(selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) && isAllSelected;
-    const newSelection = getNewSelection(id, checked);
+    const {
+      selected: newSelection,
+      groups
+    } = getNewSelection(id, checked);
     const newState = (0, calculateSelectionState_1.calculateSelectionState)(entities, newSelection, wasAllSelected, checkboxVisible, checkboxDisabled, selectable === null || selectable === void 0 ? void 0 : selectable.strategy);
     // MYG-142234: once selection spans "all" pages, unchecking a row must keep `all: true`
     // and only record the exclusion - it must not collapse to the current page's ids.
-    const newValue = wasAllSelected ? {
-      selected: [...newSelection],
-      all: true
-    } : {
+    const newValue = wasAllSelected ? (0, groupExclusions_1.createExcludedSelection)(newSelection, groups) : {
       selected: [...newSelection],
       all: newState === interfaces_1.SelectionState.All
     };
@@ -190,24 +202,43 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
     setSelectMode(newValue.all || newValue.selected.length > 0);
   }, [checkboxDisabled, checkboxVisible, entities, selectable, setSelectMode, setState, getNewSelection, isAllSelected]);
   const onBatchSelect = (0, react_1.useCallback)((rangeIds, select, base) => {
-    const result = new Set(base);
+    const result = new Set(base.selected);
+    const groups = new Set(base.excludedGroupIds);
     const limit = selectable === null || selectable === void 0 ? void 0 : selectable.selectionLimit;
     const wasAllSelected = !!(selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) && isAllSelected;
     for (const id of rangeIds) {
       if (!wasAllSelected && select && limit !== undefined && result.size >= limit) {
         break;
       }
-      (0, checkRow_1.checkRow)(result, wrappedSelectable, entities, id, wasAllSelected ? !select : select);
+      if (wasAllSelected) {
+        (0, groupExclusions_1.checkExcludedRow)(result, groups, wrappedSelectable, entities, id, select);
+      } else {
+        (0, checkRow_1.checkRow)(result, wrappedSelectable, entities, id, select);
+      }
     }
     const newState = (0, calculateSelectionState_1.calculateSelectionState)(entities, result, wasAllSelected, checkboxVisible, checkboxDisabled, selectable === null || selectable === void 0 ? void 0 : selectable.strategy);
-    const newValue = {
+    const newValue = wasAllSelected ? (0, groupExclusions_1.createExcludedSelection)(result, groups) : {
       selected: [...result],
-      all: wasAllSelected || newState === interfaces_1.SelectionState.All
+      all: newState === interfaces_1.SelectionState.All
     };
     setState(newState);
     selectable === null || selectable === void 0 ? void 0 : selectable.onSelect(newValue);
     setSelectMode(newValue.all || newValue.selected.length > 0);
   }, [entities, selectable, wrappedSelectable, checkboxVisible, checkboxDisabled, setSelectMode, isAllSelected]);
+  // Persist group intent separately from concrete IDs so remounts and incremental batches agree.
+  (0, react_1.useEffect)(() => {
+    previousDatasetId.current = selectable === null || selectable === void 0 ? void 0 : selectable.selectionDatasetId;
+  }, [selectable === null || selectable === void 0 ? void 0 : selectable.selectionDatasetId]);
+  (0, react_1.useEffect)(() => {
+    const applied = selectable === null || selectable === void 0 ? void 0 : selectable.selection;
+    if (!applied || !resolvedSelection || !selectable.allowExclusions || !applied.all || selectable.strategy !== "nested") {
+      return;
+    }
+    const sameIds = (left = [], right = []) => left.length === right.length && left.every((id, index) => id === right[index]);
+    if (!sameIds(applied.selected, resolvedSelection.selected) || !sameIds(applied.excludedGroupIds, resolvedSelection.excludedGroupIds)) {
+      selectable.onSelect(resolvedSelection);
+    }
+  }, [selectable, resolvedSelection]);
   // Deliberately independent of the current selection, so the drag anchor survives the
   // selection changes a drag itself produces.
   const {
@@ -218,7 +249,12 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
     const entity = entityById.get(row.id);
     return !!entity && checkboxVisible(entity, row.isNested) && !checkboxDisabled(entity, row.isNested);
   }, [entityById, checkboxVisible, checkboxDisabled]);
-  const getBaseSelection = (0, react_1.useCallback)(() => isAllSelected && !(selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) ? (0, getCurrentPageSelection_1.getCurrentPageSelection)(entities, wrappedSelectable) : new Set(selections), [isAllSelected, selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions, entities, wrappedSelectable, selections]);
+  const getBaseSelection = (0, react_1.useCallback)(() => Object.assign({
+    all: isAllSelected,
+    selected: [...(isAllSelected && !(selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) ? (0, getCurrentPageSelection_1.getCurrentPageSelection)(entities, wrappedSelectable) : selections)]
+  }, excludedGroupIds.size > 0 ? {
+    excludedGroupIds: [...excludedGroupIds]
+  } : {}), [isAllSelected, selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions, entities, wrappedSelectable, selections, excludedGroupIds]);
   const {
     onCheckboxMouseDown,
     suppressNextChangeRef
@@ -231,7 +267,7 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
     onSelectListener(id, checked);
   }, [onSelectListener, suppressNextChangeRef]);
   const onChangeSelectionState = (0, react_1.useCallback)(newState => {
-    var _a, _b, _c;
+    var _a;
     if (newState === interfaces_1.SelectionState.All) {
       (selectable === null || selectable === void 0 ? void 0 : selectable.onSelect) && selectable.onSelect({
         selected: [],
@@ -250,17 +286,16 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
     }
     const newSelections = (0, getCurrentPageSelection_1.getCurrentPageSelection)(entities, wrappedSelectable);
     setState(newState);
-    const previousSelections = (_b = (_a = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _a === void 0 ? void 0 : _a.selected) !== null && _b !== void 0 ? _b : [];
-    const newValue = (selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) && ((_c = selectable.selection) === null || _c === void 0 ? void 0 : _c.all) ? {
-      selected: previousSelections.filter(id => !newSelections.has(id)),
-      all: true
-    } : {
+    const previousSelections = [...selections];
+    const groups = new Set(excludedGroupIds);
+    entities.forEach(entity => groups.delete(entity.id));
+    const newValue = (selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) && ((_a = selectable.selection) === null || _a === void 0 ? void 0 : _a.all) ? (0, groupExclusions_1.createExcludedSelection)(new Set(previousSelections.filter(id => !newSelections.has(id))), groups) : {
       selected: [...new Set([...previousSelections, ...newSelections])],
       all: false
     };
     selectable === null || selectable === void 0 ? void 0 : selectable.onSelect(newValue);
     setSelectMode(newValue.all || newValue.selected.length > 0);
-  }, [selectable, wrappedSelectable, entities, setSelectMode]);
+  }, [selectable, wrappedSelectable, entities, setSelectMode, selections, excludedGroupIds]);
   const checkboxTitle = (0, react_1.useCallback)(entity => (selectable === null || selectable === void 0 ? void 0 : selectable.checkboxTitle) ? selectable.checkboxTitle(entity) : firstColumnId ? entity[firstColumnId] || entity.id : entity.id, [firstColumnId, selectable]);
   const headerTitle = (0, react_1.useCallback)(() => {
     if (selectable === null || selectable === void 0 ? void 0 : selectable.headerTitle) {
@@ -276,7 +311,15 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
   // row must be evaluated through the SelectionState.All (exclusion-aware) branch of
   // isRowChecked - not the per-page `state`, which can be Partial/None for a page that
   // contains some of those exclusions.
-  (entity, isNested) => (0, isRowChecked_1.isRowChecked)(selections, isAllSelected ? interfaces_1.SelectionState.All : state, selectable === null || selectable === void 0 ? void 0 : selectable.strategy, entity, isNested, checkboxVisible, checkboxDisabled), [selections, isAllSelected, state, selectable === null || selectable === void 0 ? void 0 : selectable.strategy, checkboxVisible, checkboxDisabled]);
+  (entity, isNested) => {
+    if (!isNested && isAllSelected && excludedGroupIds.has(entity.id)) {
+      return {
+        indeterminate: false,
+        checked: false
+      };
+    }
+    return (0, isRowChecked_1.isRowChecked)(selections, isAllSelected ? interfaces_1.SelectionState.All : state, selectable === null || selectable === void 0 ? void 0 : selectable.strategy, entity, isNested, checkboxVisible, checkboxDisabled);
+  }, [selections, excludedGroupIds, isAllSelected, state, selectable === null || selectable === void 0 ? void 0 : selectable.strategy, checkboxVisible, checkboxDisabled]);
   const hasSelectable = !!selectable;
   const selectableCheckboxSelectsCurrentPage = selectable === null || selectable === void 0 ? void 0 : selectable.checkboxSelectsCurrentPage;
   const selectableTurnOffSelectAll = selectable === null || selectable === void 0 ? void 0 : selectable.turnOffSelectAll;
@@ -342,13 +385,17 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
               // keep `all: true` - it must never be treated as an inclusion list, or
               // every other page's selection would be silently wiped out.
               const currentPageIds = (0, getCurrentPageSelection_1.getCurrentPageSelection)(entities, wrappedSelectable);
-              const newExcluded = new Set([...selectable.selection.selected, ...currentPageIds]);
-              const newState = (0, calculateSelectionState_1.calculateSelectionState)(entities, newExcluded, true, checkboxVisible, checkboxDisabled, selectable.strategy);
+              const newExcluded = new Set([...selections, ...currentPageIds]);
+              const groups = new Set(excludedGroupIds);
+              if (selectable.strategy === "nested") {
+                entities.forEach(entity => {
+                  var _a;
+                  if ((_a = (0, showMoreRow_1.getChildrenForSelection)(entity)) === null || _a === void 0 ? void 0 : _a.length) groups.add(entity.id);
+                });
+              }
+              const newState = (0, calculateSelectionState_1.calculateSelectionState)(entities, new Set([...newExcluded, ...groups]), true, checkboxVisible, checkboxDisabled, selectable.strategy);
               setState(newState);
-              selectable.onSelect({
-                selected: [...newExcluded],
-                all: true
-              });
+              selectable.onSelect((0, groupExclusions_1.createExcludedSelection)(newExcluded, groups));
               setSelectMode(true);
             } else {
               // Intentionally different from onSelect(None) ("Deselect all" menu item, which clears everything).
@@ -364,7 +411,7 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
               setSelectMode(remaining.length > 0);
             }
           },
-          calculateSelectionState: () => selectionMenuState,
+          calculateSelectionState: () => isAllSelected ? selections.size === 0 && excludedGroupIds.size === 0 ? interfaces_1.SelectionState.All : interfaces_1.SelectionState.Partial : selections.size === 0 ? interfaces_1.SelectionState.None : selectableState === interfaces_1.SelectionState.CurrentPage ? interfaces_1.SelectionState.CurrentPage : interfaces_1.SelectionState.Partial,
           checkboxInHeader: checkboxInHeaderValue,
           header: selectableHeader,
           onSelect: newState => {
@@ -377,7 +424,7 @@ const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMod
         return cell;
       }
     };
-  }, [checkboxDisabled, checkboxTitle, checkboxVisible, headerTitle, onChangeSelectionState, onCheckboxChange, onCheckboxMouseDown, hasSelectable, checkboxEmitsCurrentPage, checkboxInHeaderValue, selectableHeader, selectableTurnOffSelectAll, isInfinite, selectable, wrappedSelectable, selectionMenuState, state, isMobile, checkboxPlaceholder, isEntityChecked, entities, setSelectMode]);
+  }, [checkboxDisabled, checkboxTitle, checkboxVisible, headerTitle, onChangeSelectionState, onCheckboxChange, onCheckboxMouseDown, hasSelectable, checkboxEmitsCurrentPage, checkboxInHeaderValue, selectableHeader, selectableTurnOffSelectAll, isInfinite, selectable, wrappedSelectable, selectableState, isAllSelected, selections, excludedGroupIds, state, isMobile, checkboxPlaceholder, isEntityChecked, entities, setSelectMode]);
   const selectableFeedWrapper = (0, react_1.useCallback)((primaryData, secondaryData, entity, isNested) => {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!entity) {

package/dist/table/selectable/utils/calculateSelectionState.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateSelectionState = void 0;
 const showMoreRow_1 = require("../../../commonHelpers/showMoreRow");
 const interfaces_1 = require("../interfaces");
+const areAllLoading = (children) => children.every(child => child.isLoading);
 const calculateSelectionState = (entities, selections, all, checkboxVisible, checkboxDisabled, strategy) => {
     if (selections.size === 0) {
         return all ? interfaces_1.SelectionState.All : interfaces_1.SelectionState.None;
@@ -12,7 +13,7 @@ const calculateSelectionState = (entities, selections, all, checkboxVisible, che
         // otherwise-fully-selected set (see ISelectionValue), rather than included ids.
         const isExcluded = (entity) => {
             const children = strategy === "nested" ? (0, showMoreRow_1.getChildrenForSelection)(entity) : undefined;
-            if (children && children.length > 0) {
+            if (children && children.length > 0 && !areAllLoading(children)) {
                 return children.every(child => {
                     if (!checkboxVisible(child, true)) {
                         return true;
@@ -27,7 +28,7 @@ const calculateSelectionState = (entities, selections, all, checkboxVisible, che
         };
         const isPartiallyExcluded = (entity) => {
             const children = strategy === "nested" ? (0, showMoreRow_1.getChildrenForSelection)(entity) : undefined;
-            if (children && children.length > 0) {
+            if (children && children.length > 0 && !areAllLoading(children)) {
                 return children.some(child => selections.has(child.id));
             }
             return selections.has(entity.id);

package/dist/table/selectable/utils/getCurrentPageSelection.js

@@ -2,17 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCurrentPageSelection = void 0;
 const showMoreRow_1 = require("../../../commonHelpers/showMoreRow");
+const isLoadingRow = (entity) => !!entity.isLoading;
 const getCurrentPageSelection = (entities, selectable) => {
     const newSelections = new Set();
     entities.forEach(entity => {
-        const isVisible = !entity.isLoading && !(0, showMoreRow_1.isShowMoreRow)(entity) && ((selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible) ? selectable.checkboxVisible(entity) : true);
+        if (isLoadingRow(entity) || (0, showMoreRow_1.isShowMoreRow)(entity)) {
+            return;
+        }
+        const isVisible = (selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible) ? selectable.checkboxVisible(entity) : true;
         const isEnabled = !(selectable === null || selectable === void 0 ? void 0 : selectable.checkboxDisabled) || !selectable.checkboxDisabled(entity);
         const children = (selectable === null || selectable === void 0 ? void 0 : selectable.strategy) === "nested" ? (0, showMoreRow_1.getChildrenForSelection)(entity) : undefined;
         if (children && children.length > 0) {
             children.forEach(child => {
-                const isChildVisible = !child.isLoading &&
-                    !(0, showMoreRow_1.isShowMoreRow)(child) &&
-                    ((selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible) ? selectable.checkboxVisible(child, true) : true);
+                if (isLoadingRow(child) || (0, showMoreRow_1.isShowMoreRow)(child)) {
+                    return;
+                }
+                const isChildVisible = (selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible) ? selectable.checkboxVisible(child, true) : true;
                 const isChildEnabled = !(selectable === null || selectable === void 0 ? void 0 : selectable.checkboxDisabled) || !selectable.checkboxDisabled(child, true);
                 if (isChildVisible && isChildEnabled) {
                     newSelections.add(child.id);

package/dist/table/selectable/utils/groupExclusions.d.ts

@@ -0,0 +1,7 @@
+import { IEntityWithId } from "../../../commonHelpers/entity";
+import { IRowEntity } from "../../../dataGrid/row/row";
+import { ISelectionValue } from "../interfaces";
+import { ISelectableRowsOptions } from "../useSelectableRows";
+export declare const createExcludedSelection: (selected: Set<string>, groups: Set<string>) => ISelectionValue;
+export declare const resolveGroupExclusions: <T extends IRowEntity<N>, N extends IEntityWithId>(entities: T[], selectable: ISelectableRowsOptions<T, N> | undefined, pruneMissingGroups?: boolean) => ISelectionValue | undefined;
+export declare const checkExcludedRow: <T extends IRowEntity<N>, N extends IEntityWithId>(selected: Set<string>, groups: Set<string>, selectable: ISelectableRowsOptions<T, N> | undefined, entities: T[], id: string, checked: boolean) => void;

package/dist/table/selectable/utils/groupExclusions.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExcludedRow = exports.resolveGroupExclusions = exports.createExcludedSelection = void 0;
+const showMoreRow_1 = require("../../../commonHelpers/showMoreRow");
+const checkRow_1 = require("./checkRow");
+const getCurrentPageSelection_1 = require("./getCurrentPageSelection");
+const createExcludedSelection = (selected, groups) => (Object.assign({ all: true, selected: [...selected] }, (groups.size > 0 ? { excludedGroupIds: [...groups] } : {})));
+exports.createExcludedSelection = createExcludedSelection;
+const resolveGroupExclusions = (entities, selectable, pruneMissingGroups = false) => {
+    var _a, _b;
+    const selection = selectable === null || selectable === void 0 ? void 0 : selectable.selection;
+    if (!(selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) || !(selection === null || selection === void 0 ? void 0 : selection.all) || selectable.strategy !== "nested") {
+        return selection;
+    }
+    const selected = new Set(selection.selected);
+    const groups = new Set(selection.excludedGroupIds);
+    for (const entity of entities) {
+        if (selected.has(entity.id) && ((_a = (0, showMoreRow_1.getChildrenForSelection)(entity)) === null || _a === void 0 ? void 0 : _a.length)) {
+            groups.add(entity.id);
+        }
+    }
+    for (const id of groups) {
+        const entity = entities.find(item => item.id === id);
+        if (!entity && pruneMissingGroups) {
+            selected.delete(id);
+            groups.delete(id);
+            continue;
+        }
+        if (!entity)
+            continue;
+        if ((_b = (0, showMoreRow_1.getChildrenForSelection)(entity)) === null || _b === void 0 ? void 0 : _b.length) {
+            selected.delete(id);
+        }
+        for (const childId of (0, getCurrentPageSelection_1.getCurrentPageSelection)([entity], selectable)) {
+            selected.add(childId);
+        }
+    }
+    return (0, exports.createExcludedSelection)(selected, groups);
+};
+exports.resolveGroupExclusions = resolveGroupExclusions;
+const checkExcludedRow = (selected, groups, selectable, entities, id, checked) => {
+    var _a, _b;
+    if ((selectable === null || selectable === void 0 ? void 0 : selectable.strategy) === "nested") {
+        const entity = entities.find(item => item.id === id);
+        if (checked) {
+            groups.delete(id);
+            selected.delete(id);
+            // Selecting a child overrides the whole-group intent, retaining the other concrete exclusions.
+            for (const parent of entities) {
+                if ((_a = (0, showMoreRow_1.getChildrenForSelection)(parent)) === null || _a === void 0 ? void 0 : _a.some(child => child.id === id)) {
+                    groups.delete(parent.id);
+                }
+            }
+        }
+        else if (entity && ((_b = (0, showMoreRow_1.getChildrenForSelection)(entity)) === null || _b === void 0 ? void 0 : _b.length)) {
+            groups.add(id);
+        }
+    }
+    (0, checkRow_1.checkRow)(selected, selectable, entities, id, !checked);
+};
+exports.checkExcludedRow = checkExcludedRow;

package/dist/table/selectable/utils/isRowChecked.js

@@ -27,7 +27,7 @@ const isRowChecked = (selections, state, strategy, entity, isNested, checkboxVis
         if (children && children.length > 0) {
             const selectableChildren = filterSelectable(children, checkboxVisible, checkboxDisabled);
             if (selectableChildren.length === 0) {
-                return { indeterminate: false, checked: true };
+                return { indeterminate: false, checked: !selections.has(entity.id) };
             }
             const allChildrenChecked = selectableChildren.every(child => !selections.has(child.id));
             const someChildrenChecked = selectableChildren.some(child => !selections.has(child.id));

package/dist/table/table.js

@@ -148,6 +148,7 @@ const useTableChildren_1 = require("./children/useTableChildren");
 const deviceType_1 = require("../commonHelpers/hooks/deviceType");
 const useMobile_1 = require("../commonHelpers/hooks/useMobile");
 const getCurrentPageSelection_1 = require("./selectable/utils/getCurrentPageSelection");
+const groupExclusions_1 = require("./selectable/utils/groupExclusions");
 const tableFullscreen_1 = require("./children/tableFullscreen");
 const tableBulkActions_1 = require("./children/tableBulkActions");
 const tablePagination_1 = require("./children/tablePagination");
@@ -235,7 +236,7 @@ const TableInner = ({
   active,
   onClick
 }) => {
-  var _a, _b, _c, _d, _e;
+  var _a, _b, _c, _d, _e, _f;
   const isMobile = (0, useMobile_1.useMobile)();
   const {
     translate
@@ -329,15 +330,15 @@ const TableInner = ({
     var _a, _b;
     return (0, useSelectableRows_1.isAllSelection)((_a = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _a === void 0 ? void 0 : _a.all, (_b = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _b === void 0 ? void 0 : _b.selected.length, selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions);
   }, [(_c = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _c === void 0 ? void 0 : _c.all, selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions, (_d = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _d === void 0 ? void 0 : _d.selected.length]);
+  const resolvedSelection = (0, react_1.useMemo)(() => (0, groupExclusions_1.resolveGroupExclusions)(entities, selectable), [entities, selectable]);
   const selectionQty = (0, react_1.useMemo)(() => {
-    var _a;
     if (!selectable) {
       return 0;
     }
-    const ids = new Set((_a = selectable.selection) === null || _a === void 0 ? void 0 : _a.selected);
+    const ids = new Set(resolvedSelection === null || resolvedSelection === void 0 ? void 0 : resolvedSelection.selected);
     const base = entities.length > 0 ? entities : loadingEntities;
     return allSelected ? [...(0, getCurrentPageSelection_1.getCurrentPageSelection)(base, selectable)].filter(id => !selectable.allowExclusions || !ids.has(id)).length : ids.size;
-  }, [selectable, entities, loadingEntities, allSelected]);
+  }, [selectable, resolvedSelection, entities, loadingEntities, allSelected]);
   const clearSelection = (0, react_1.useCallback)(() => {
     setSelectMode(false);
     selectable === null || selectable === void 0 ? void 0 : selectable.onSelect({
@@ -363,7 +364,7 @@ const TableInner = ({
     detailPanel,
     footer,
     other
-  } = (0, useTableChildren_1.useTableChildren)(children, isMobile, selectionQty, allSelected, clearSelection, activeId, gridRef, onCloseDetailPanel, isInfinite, entities.length, (selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) && ((_e = selectable.selection) === null || _e === void 0 ? void 0 : _e.all) ? new Set(selectable.selection.selected).size : 0, (selectable === null || selectable === void 0 ? void 0 : selectable.strategy) !== "nested" && !(selectable === null || selectable === void 0 ? void 0 : selectable.checkboxDisabled) && !(selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible), !!feedEndCallback || !!isLoading);
+  } = (0, useTableChildren_1.useTableChildren)(children, isMobile, selectionQty, allSelected, clearSelection, activeId, gridRef, onCloseDetailPanel, isInfinite, entities.length, (selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) && (resolvedSelection === null || resolvedSelection === void 0 ? void 0 : resolvedSelection.all) ? new Set(resolvedSelection.selected).size + ((_f = (_e = resolvedSelection.excludedGroupIds) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0) : 0, (selectable === null || selectable === void 0 ? void 0 : selectable.strategy) !== "nested" && !(selectable === null || selectable === void 0 ? void 0 : selectable.checkboxDisabled) && !(selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible), !!feedEndCallback || !!isLoading);
   const hasDetailPanel = !!detailPanel;
   const shouldEnableRowClick = hasDetailPanel || !!onClick;
   const activeIdForRow = shouldEnableRowClick ? activeId : undefined;

package/dist/waiting/waiting.js

@@ -21,7 +21,9 @@ const Waiting = ({ isLoading = false, delay = 400, hideOverlay = false, classNam
     // its coverage layer to the parent's scrollHeight would incorrectly block clicks below the spinner
     // and grow the parent's own scrollHeight on every re-measure (a feedback loop).
     const isInline = className.split(/\s+/).includes("zen-waiting--inline");
-    const canMeasureCoverage = showWaiting && !isInline;
+    // Callers using hideOverlay intentionally keep the surrounding controls interactive (for
+    // example, the MiniMap address textarea while its preview is loading).
+    const canMeasureCoverage = showWaiting && !isInline && !hideOverlay;
     const measureCoverage = (0, react_1.useCallback)(() => {
         var _a;
         const parent = (_a = waitingRef.current) === null || _a === void 0 ? void 0 : _a.parentElement;

package/esm/dataGrid/withSelectableRows/components/bulkActions/bulkActions.d.ts

@@ -12,7 +12,7 @@ export interface IBulkActionsProps extends IZenComponentProps {
      * even when `selected` is 0 (i.e., cross-page "select all" is active).
      */
     allSelected?: boolean;
-    /** Show a selection label without a count when the selected total is unknown. */
+    /** The selection spans unloaded rows and its total is not available. */
     selectionCountUnknown?: boolean;
     onClearSelection: () => void;
     onSelectAll?: () => void;

package/esm/dropdownRaw/dropdownHelper.d.ts

@@ -12,12 +12,28 @@ export declare const isAllItemsHasOneParent: (listData: IDropdownRawItem[], chil
 export declare function prepareComboOptionsForList(actionListData: Set<string>, translate: (s: string) => string, options: IDropdownRawItem[], getSelectedFn: () => string[], getSelectedChildFn: (optionId: any) => string[], isFlatList: boolean, getTitle?: (itemId: string) => string, isAllSelected?: boolean): ICheckboxListWithActionOption[];
 export declare const createOptions: (stateObj: IDropdownState, translate: (s: string) => string, listItem: IDropdownRawItem[], isAllSelected?: boolean) => ICheckboxListWithActionOption[];
 export declare const sortDropdownItemArray: (arr: IDropdownRawItem[], sortFn?: (a: IDropdownRawItem, b: IDropdownRawItem) => number) => IDropdownRawItem[];
+/**
+ * An item is half selected when at least one of its direct children is selected — the state its checkbox
+ * shows as indeterminate (see `prepareComboOptionsForList`). `selectedSet` is passed in so the sort can use
+ * its own snapshot of the selection instead of the live one.
+ */
+export declare const hasSelectedChild: (groupsMap: IDropdownState["groupsMap"], itemId: string, selectedSet: Set<string>) => boolean;
+interface ISortSelectedToTopOptions {
+    /** Items that count as selected although their own id is not, e.g. a half selected parent. */
+    isPartiallySelected?: (item: IDropdownRawItem) => boolean;
+    /** Disabled items cannot be toggled, so they follow the selectable ones. */
+    isDisabled?: (item: IDropdownRawItem) => boolean;
+}
 /**
  * Floats selected items to the top of the list while preserving the relative order within each
- * group (selected and unselected). When `selectedIds` is empty the original array is returned
- * unchanged (no allocation). Uses a single-pass partition to avoid traversing `items` twice.
+ * group. The order is: selected items that can be toggled, then selected items that are disabled
+ * (so a newly selected item is never pushed down by disabled ones), then everything else. An item
+ * counts as selected when its own id is in `selectedIds` or when `isPartiallySelected` returns true
+ * for it, so half selected items sit with the selected ones. When `selectedIds` is empty the original
+ * array is returned unchanged (no allocation). Uses a single-pass partition to avoid traversing
+ * `items` more than once.
  */
-export declare const applySortSelectedToTop: (items: IDropdownRawItem[], selectedIds: string[]) => IDropdownRawItem[];
+export declare const applySortSelectedToTop: (items: IDropdownRawItem[], selectedIds: string[], { isPartiallySelected, isDisabled }?: ISortSelectedToTopOptions) => IDropdownRawItem[];
 export declare const createSingleListOptions: (stateObj: IDropdownState, translate: (s: string) => string, listItem: IDropdownRawItem[]) => {
     destructive: boolean | undefined;
     divider?: boolean | undefined;
@@ -56,3 +72,4 @@ export declare const getAllyTriggerProps: (allyPattern: "selectOnlyCombobox" | "
     readonly role: "button";
     readonly "aria-haspopup": "menu";
 };
+export {};

package/esm/dropdownRaw/dropdownHelper.js

@@ -81,21 +81,43 @@ export const sortDropdownItemArray = (arr, sortFn) => {
     }
     return arr;
 };
+/**
+ * An item is half selected when at least one of its direct children is selected — the state its checkbox
+ * shows as indeterminate (see `prepareComboOptionsForList`). `selectedSet` is passed in so the sort can use
+ * its own snapshot of the selection instead of the live one.
+ */
+export const hasSelectedChild = (groupsMap, itemId, selectedSet) => {
+    const group = groupsMap[itemId];
+    return group ? getChildList(group.children).some(child => selectedSet.has(child.id)) : false;
+};
 /**
  * Floats selected items to the top of the list while preserving the relative order within each
- * group (selected and unselected). When `selectedIds` is empty the original array is returned
- * unchanged (no allocation). Uses a single-pass partition to avoid traversing `items` twice.
+ * group. The order is: selected items that can be toggled, then selected items that are disabled
+ * (so a newly selected item is never pushed down by disabled ones), then everything else. An item
+ * counts as selected when its own id is in `selectedIds` or when `isPartiallySelected` returns true
+ * for it, so half selected items sit with the selected ones. When `selectedIds` is empty the original
+ * array is returned unchanged (no allocation). Uses a single-pass partition to avoid traversing
+ * `items` more than once.
  */
-export const applySortSelectedToTop = (items, selectedIds) => {
+export const applySortSelectedToTop = (items, selectedIds, { isPartiallySelected, isDisabled } = {}) => {
     if (!selectedIds.length)
         return items;
     const selectedSet = new Set(selectedIds);
     const selected = [];
+    const selectedDisabled = [];
     const unselected = [];
     for (const item of items) {
-        (selectedSet.has(item.id) ? selected : unselected).push(item);
+        if (!selectedSet.has(item.id) && !(isPartiallySelected === null || isPartiallySelected === void 0 ? void 0 : isPartiallySelected(item))) {
+            unselected.push(item);
+        }
+        else if (isDisabled === null || isDisabled === void 0 ? void 0 : isDisabled(item)) {
+            selectedDisabled.push(item);
+        }
+        else {
+            selected.push(item);
+        }
     }
-    return [...selected, ...unselected];
+    return [...selected, ...selectedDisabled, ...unselected];
 };
 export const createSingleListOptions = (stateObj, translate, listItem) => {
     const preparedOptions = listItem && listItem.length

package/esm/dropdownRaw/dropdownRaw.js

@@ -8,7 +8,7 @@ import { getInitialState, stateReducer, ROOT_GROUP_ID } from "./stateReducer/sta
 import { StateActionType } from "./stateReducer/stateActionType";
 import { FOCUSABLE_SELECTOR } from "../utils/focusableSelector";
 import { useEscape } from "../commonHelpers/hooks/useEscape";
-import { applySortSelectedToTop, checkIsDataProblem, compareObjectsArrays, compareStringsArrays, createListDataOptions, getDataForChange, getListDataWithDisabled, getSelectedCount, getStringFromAllSelected, getStringFromSelected, isAllChildrenSelected, isAllItemsHasOneParent, isEveryItemSelected, prepareSelectedIdsToItems, sortDropdownItemArray } from "./dropdownHelper";
+import { applySortSelectedToTop, hasSelectedChild, checkIsDataProblem, compareObjectsArrays, compareStringsArrays, createListDataOptions, getDataForChange, getListDataWithDisabled, getSelectedCount, getStringFromAllSelected, getStringFromSelected, isAllChildrenSelected, isAllItemsHasOneParent, isEveryItemSelected, prepareSelectedIdsToItems, sortDropdownItemArray } from "./dropdownHelper";
 import { DropdownTrigger } from "./dropdownTrigger";
 import { isFocusable } from "../dialog/dialogHelpers";
 import { useLanguage } from "../utils/localization/useLanguage";
@@ -1147,20 +1147,36 @@ export const DropdownRaw = props => {
         // hasApplyButton=true: uses globalSelectedIds (committed selection) — reordering
         //   only takes effect after the user clicks "Apply".
         const idsForSort = hasApplyButton ? state.globalSelectedIds : state.sortedTopSnapshot;
-        const floated = sortSelectedToTop ? applySortSelectedToTop(children, idsForSort) : children;
-        rawItems = floated.slice(0, listLimit);
         if (sortSelectedToTop) {
+          // Half selected items (a direct child is selected, shown as indeterminate) float with the selected ones.
+          // Disabled selected items follow the selectable ones; in a nested list `disabled` is not enforced (see createOptions).
           const selectedSet = new Set(idsForSort);
-          pinnedCount = rawItems.filter(item => selectedSet.has(item.id)).length;
+          const isPartiallySelected = item => hasSelectedChild(state.groupsMap, item.id, selectedSet);
+          const isDisabled = item => Boolean(item.disabled) && !state.isNestedList;
+          rawItems = applySortSelectedToTop(children, idsForSort, {
+            isPartiallySelected,
+            isDisabled
+          }).slice(0, listLimit);
+          pinnedCount = rawItems.filter(item => selectedSet.has(item.id) || isPartiallySelected(item)).length;
+        } else {
+          rawItems = children.slice(0, listLimit);
         }
       }
       const listData = createListDataOptions(state, translate, rawItems, multiselect, currentAllSelected);
       // Explicit bounds check (rather than relying on CheckboxListWithAction's own
       // `ind < optionsArr.length - 1` guard) keeps the "don't draw a trailing divider"
       // intent local to where the boundary is computed.
-      const currentListData = multiselect && sortSelectedToTop && pinnedCount > 0 && pinnedCount < listData.length ? listData.map((opt, ind) => ind === pinnedCount - 1 ? Object.assign(Object.assign({}, opt), {
-        divider: true
-      }) : opt) : listData;
+      // Floated items drop their own dividers, so the boundary divider is the only one drawn between them and the rest.
+      const currentListData = multiselect && sortSelectedToTop && pinnedCount > 0 && pinnedCount < listData.length ? listData.map((opt, ind) => {
+        if (ind === pinnedCount - 1) {
+          return Object.assign(Object.assign({}, opt), {
+            divider: true
+          });
+        }
+        return ind < pinnedCount && opt.divider ? Object.assign(Object.assign({}, opt), {
+          divider: false
+        }) : opt;
+      }) : listData;
       return _jsx(DropdownList, {
         onBackButtonClick: handleBackButtonClick,
         onSelectAllClick: isSearchMode ? handleSelectAllInSearch : handleSelectAllClick,