@geotab/zenith 3.16.0 → 3.17.0-beta.0

package/esm/table/selectable/useSelectableRows.js

@@ -1,5 +1,6 @@
 import { injectString } from "../../utils/localization/translationsDictionary";
 import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable complexity */
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { SelectionState } from "./interfaces";
 import { CheckboxCell } from "../../dataGrid/columns/checkboxColumn/checkboxCell";
@@ -10,6 +11,9 @@ import { useLanguage } from "../../utils/localization/useLanguage";
 import { checkRow } from "./utils/checkRow";
 import { isRowChecked } from "./utils/isRowChecked";
 import { getCurrentPageSelection } from "./utils/getCurrentPageSelection";
+import { useDragSelection } from "./useDragSelection";
+import { getDragSelectionRows } from "./utils/getDragSelectionRows";
+import { isShowMoreRow } from "../../commonHelpers/showMoreRow";
 injectString("cs", "Select all", "Vybrat v\u0161e");
 injectString("da-DK", "Select all", "V\xE6lg alle");
 injectString("de", "Select all", "Alle ausw\xE4hlen");
@@ -80,10 +84,12 @@ export const getEmptySelection = () => ({
   all: false,
   selected: []
 });
+export const isAllSelection = (all, selectedCount, allowExclusions) => !!all && (!!allowExclusions || selectedCount === 0);
 export const 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;
-export const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMode, selectable, isInfinite = false) => {
+const getSelectionMenuState = (allSelected, selections, pageState) => allSelected ? selections.size === 0 ? SelectionState.All : SelectionState.Partial : pageState;
+export const useSelectableRows = (columns, entities, isMobile, selectMode, setSelectMode, selectable, isInfinite = false, gridRef, expandedRows) => {
   var _a;
   const {
     translate
@@ -91,13 +97,12 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
   const selections = useMemo(() => getSelections(selectable === null || selectable === void 0 ? void 0 : selectable.selection), [selectable === null || selectable === void 0 ? void 0 : selectable.selection]);
   const [state, setState] = useState(SelectionState.None);
   const checkboxVisible = useMemo(() => {
-    if (selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible) {
-      return selectable.checkboxVisible;
-    }
-    if ((selectable === null || selectable === void 0 ? void 0 : selectable.strategy) !== "nested") {
-      return (_, isNested) => !isNested;
-    }
-    return () => true;
+    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;
+    // Synthetic "+N more" and loading placeholder rows are never selectable.
+    return (entity, isNested) => {
+      if (isShowMoreRow(entity) || entity.isLoading) return false;
+      return base(entity, isNested);
+    };
   }, [selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible, selectable === null || selectable === void 0 ? void 0 : selectable.strategy]);
   const checkboxDisabled = useMemo(() => {
     if (selectable === null || selectable === void 0 ? void 0 : selectable.checkboxDisabled) {
@@ -109,6 +114,12 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
     }
     return () => false;
   }, [selectable, selections]);
+  // `checkRow` and `getCurrentPageSelection` read callbacks off `selectable`, so hand them the
+  // wrapped ones to apply the same exclusions.
+  const wrappedSelectable = useMemo(() => selectable ? Object.assign(Object.assign({}, selectable), {
+    checkboxVisible,
+    checkboxDisabled
+  }) : undefined, [selectable, checkboxVisible, checkboxDisabled]);
   const checkboxPlaceholder = useMemo(() => {
     if ((selectable === null || selectable === void 0 ? void 0 : selectable.checkboxPlaceholder) !== undefined) {
       return selectable.checkboxPlaceholder;
@@ -121,40 +132,96 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
   }, [selectable === null || selectable === void 0 ? void 0 : selectable.checkboxPlaceholder, selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible, selectable === null || selectable === void 0 ? void 0 : selectable.strategy]);
   const isAllSelected = useMemo(() => {
     var _a;
-    return ((_a = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _a === void 0 ? void 0 : _a.all) || false;
-  }, [(_a = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _a === void 0 ? void 0 : _a.all]);
+    return 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 = useMemo(() => 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 firstColumnId = useMemo(() => columns.length > 0 ? columns[0].id : null, [columns]);
   useEffect(() => {
     if (selectable && selectable.selection) {
       const newSelections = new Set(selectable.selection.selected);
-      const newState = calculateSelectionState(entities, newSelections, selectable.selection.all || false, checkboxVisible, checkboxDisabled, selectable.strategy);
+      const newState = calculateSelectionState(entities, newSelections, isAllSelected, checkboxVisible, checkboxDisabled, selectable.strategy);
       setState(newState);
     }
-  }, [checkboxDisabled, checkboxVisible, entities, selectable, setSelectMode, selectable === null || selectable === void 0 ? void 0 : selectable.strategy]);
+  }, [checkboxDisabled, checkboxVisible, entities, selectable, setSelectMode, selectable === null || selectable === void 0 ? void 0 : selectable.strategy, isAllSelected]);
   const getNewSelection = useCallback((id, checked) => {
-    if (state === SelectionState.All) {
-      const newSelection = getCurrentPageSelection(entities, selectable);
-      checkRow(newSelection, selectable, entities, id, false);
-      return newSelection;
+    if (isAllSelected && !(selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions)) {
+      const included = getCurrentPageSelection(entities, wrappedSelectable);
+      checkRow(included, wrappedSelectable, entities, id, checked);
+      return included;
     }
-    checkRow(selections, selectable, entities, id, checked);
+    if (isAllSelected) {
+      // MYG-142234: `selections` holds the ids excluded from the "all" selection.
+      // Toggling a row here must only ever add/remove that single id from the
+      // 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);
+      checkRow(excluded, wrappedSelectable, entities, id, !checked);
+      return excluded;
+    }
+    checkRow(selections, wrappedSelectable, entities, id, checked);
     return selections;
-  }, [state, entities, selectable, selections]);
+  }, [entities, selectable, wrappedSelectable, selections, isAllSelected]);
   const onSelectListener = useCallback((id, checked) => {
-    var _a;
+    const wasAllSelected = !!(selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) && isAllSelected;
     const newSelection = getNewSelection(id, checked);
-    const newState = calculateSelectionState(entities, newSelection, ((_a = selectable === null || selectable === void 0 ? void 0 : selectable.selection) === null || _a === void 0 ? void 0 : _a.all) || false, checkboxVisible, checkboxDisabled, selectable === null || selectable === void 0 ? void 0 : selectable.strategy);
-    const newValue = {
+    const newState = 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
+    } : {
       selected: [...newSelection],
       all: newState === SelectionState.All
     };
     setState(newState);
     selectable === null || selectable === void 0 ? void 0 : selectable.onSelect(newValue);
     setSelectMode(newValue.all || newValue.selected.length > 0);
-  }, [checkboxDisabled, checkboxVisible, entities, selectable, setSelectMode, setState, getNewSelection]);
+  }, [checkboxDisabled, checkboxVisible, entities, selectable, setSelectMode, setState, getNewSelection, isAllSelected]);
+  const onBatchSelect = useCallback((rangeIds, select, base) => {
+    const result = new Set(base);
+    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;
+      }
+      checkRow(result, wrappedSelectable, entities, id, wasAllSelected ? !select : select);
+    }
+    const newState = calculateSelectionState(entities, result, wasAllSelected, checkboxVisible, checkboxDisabled, selectable === null || selectable === void 0 ? void 0 : selectable.strategy);
+    const newValue = {
+      selected: [...result],
+      all: wasAllSelected || newState === 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]);
+  // Deliberately independent of the current selection, so the drag anchor survives the
+  // selection changes a drag itself produces.
+  const {
+    rows: dragRows,
+    entityById
+  } = useMemo(() => getDragSelectionRows(entities, expandedRows), [entities, expandedRows]);
+  const isSelectable = useCallback(row => {
+    const entity = entityById.get(row.id);
+    return !!entity && checkboxVisible(entity, row.isNested) && !checkboxDisabled(entity, row.isNested);
+  }, [entityById, checkboxVisible, checkboxDisabled]);
+  const getBaseSelection = useCallback(() => isAllSelected && !(selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions) ? getCurrentPageSelection(entities, wrappedSelectable) : new Set(selections), [isAllSelected, selectable === null || selectable === void 0 ? void 0 : selectable.allowExclusions, entities, wrappedSelectable, selections]);
+  const {
+    onCheckboxMouseDown,
+    suppressNextChangeRef
+  } = useDragSelection(dragRows, gridRef, onBatchSelect, getBaseSelection, isSelectable, !!selectable);
+  const onCheckboxChange = useCallback((id, checked) => {
+    if (suppressNextChangeRef.current) {
+      suppressNextChangeRef.current = false;
+      return;
+    }
+    onSelectListener(id, checked);
+  }, [onSelectListener, suppressNextChangeRef]);
   const onChangeSelectionState = useCallback(newState => {
-    var _a, _b;
+    var _a, _b, _c;
     if (newState === SelectionState.All) {
       (selectable === null || selectable === void 0 ? void 0 : selectable.onSelect) && selectable.onSelect({
         selected: [],
@@ -171,17 +238,19 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
       setSelectMode(false);
       return;
     }
-    const newSelections = getCurrentPageSelection(entities, selectable);
+    const newSelections = 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 mergedSelections = new Set([...previousSelections, ...newSelections]);
-    const newValue = {
-      selected: [...mergedSelections],
+    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
+    } : {
+      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, entities, setSelectMode]);
+  }, [selectable, wrappedSelectable, entities, setSelectMode]);
   const checkboxTitle = 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 = useCallback(() => {
     if (selectable === null || selectable === void 0 ? void 0 : selectable.headerTitle) {
@@ -192,7 +261,12 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
     }
     return translate("Deselect all");
   }, [selectable, selectableState, state, translate]);
-  const isEntityChecked = useCallback((entity, isNested) => isRowChecked(selections, state, selectable === null || selectable === void 0 ? void 0 : selectable.strategy, entity, isNested), [selections, state, selectable === null || selectable === void 0 ? void 0 : selectable.strategy]);
+  const isEntityChecked = useCallback(
+  // MYG-142234: while `selection.all` is true, `selections` holds excluded ids, and every
+  // 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) => isRowChecked(selections, isAllSelected ? 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]);
   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;
@@ -230,7 +304,8 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
           indeterminate: checked.indeterminate,
           disabled: isDisable,
           label: checkboxTitle(entity),
-          onChange: onSelectListener,
+          onChange: onCheckboxChange,
+          onMouseDown: isDisable ? undefined : onCheckboxMouseDown,
           children: _jsx(CheckboxCell.Content, {
             children: value
           })
@@ -244,16 +319,32 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
           checked: state === SelectionState.CurrentPage || state === SelectionState.All,
           indeterminate: state === SelectionState.Partial,
           onChange: newValue => {
-            var _a, _b;
+            var _a, _b, _c;
             if (newValue) {
               const newState = checkboxEmitsCurrentPage ? SelectionState.CurrentPage : SelectionState.All;
               setState(newState);
               onChangeSelectionState(newState);
+            } else if (isInfinite) {
+              onChangeSelectionState(SelectionState.None);
+            } else if (selectable.allowExclusions && ((_a = selectable.selection) === null || _a === void 0 ? void 0 : _a.all)) {
+              // MYG-142234: in exclusion mode, `selected` holds excluded ids. Unchecking
+              // the header must add the current page's ids to that exclusion set and
+              // 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 = getCurrentPageSelection(entities, wrappedSelectable);
+              const newExcluded = new Set([...selectable.selection.selected, ...currentPageIds]);
+              const newState = calculateSelectionState(entities, newExcluded, true, checkboxVisible, checkboxDisabled, selectable.strategy);
+              setState(newState);
+              selectable.onSelect({
+                selected: [...newExcluded],
+                all: true
+              });
+              setSelectMode(true);
             } else {
               // Intentionally different from onSelect(None) ("Deselect all" menu item, which clears everything).
               // Unchecking the header checkbox only removes the current page from the selection, preserving other pages.
-              const currentPageIds = getCurrentPageSelection(entities, selectable);
-              const remaining = ((_b = (_a = selectable.selection) === null || _a === void 0 ? void 0 : _a.selected) !== null && _b !== void 0 ? _b : []).filter(id => !currentPageIds.has(id));
+              const currentPageIds = getCurrentPageSelection(entities, wrappedSelectable);
+              const remaining = ((_c = (_b = selectable.selection) === null || _b === void 0 ? void 0 : _b.selected) !== null && _c !== void 0 ? _c : []).filter(id => !currentPageIds.has(id));
               const newState = remaining.length > 0 ? SelectionState.Partial : SelectionState.None;
               setState(newState);
               selectable.onSelect({
@@ -263,7 +354,7 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
               setSelectMode(remaining.length > 0);
             }
           },
-          calculateSelectionState: () => selectableState,
+          calculateSelectionState: () => selectionMenuState,
           checkboxInHeader: checkboxInHeaderValue,
           header: selectableHeader,
           onSelect: newState => {
@@ -276,7 +367,7 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
         return cell;
       }
     };
-  }, [checkboxDisabled, checkboxTitle, checkboxVisible, headerTitle, onChangeSelectionState, onSelectListener, hasSelectable, checkboxEmitsCurrentPage, checkboxInHeaderValue, selectableHeader, selectableTurnOffSelectAll, isInfinite, selectable, selectableState, state, isMobile, checkboxPlaceholder, isEntityChecked, entities, setSelectMode]);
+  }, [checkboxDisabled, checkboxTitle, checkboxVisible, headerTitle, onChangeSelectionState, onCheckboxChange, onCheckboxMouseDown, hasSelectable, checkboxEmitsCurrentPage, checkboxInHeaderValue, selectableHeader, selectableTurnOffSelectAll, isInfinite, selectable, wrappedSelectable, selectionMenuState, state, isMobile, checkboxPlaceholder, isEntityChecked, entities, setSelectMode]);
   const selectableFeedWrapper = useCallback((primaryData, secondaryData, entity, isNested) => {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!entity) {
@@ -285,6 +376,9 @@ export const useSelectableRows = (columns, entities, isMobile, selectMode, setSe
     if (!isMobile) {
       return [primaryData, secondaryData];
     }
+    if (entity.isLoading) {
+      return [primaryData, secondaryData];
+    }
     if (!selectMode) {
       return [primaryData, secondaryData];
     }

package/esm/table/selectable/utils/calculateSelectionState.d.ts

@@ -2,4 +2,4 @@ import { IEntityWithId } from "../../../commonHelpers/entity";
 import { IRowEntity } from "../../../dataGrid/row/row";
 import { SelectionState } from "../interfaces";
 import { TSelectionStrategy } from "../useSelectableRows";
-export declare const calculateSelectionState: <T extends IRowEntity<N>, N extends IEntityWithId>(entities: T[], selections: Set<string>, all: boolean, checkboxVisible: (e: T | N) => boolean, checkboxDisabled: (e: T | N) => boolean, strategy?: TSelectionStrategy) => SelectionState;
+export declare const calculateSelectionState: <T extends IRowEntity<N>, N extends IEntityWithId>(entities: T[], selections: Set<string>, all: boolean, checkboxVisible: (e: T | N, isNested?: boolean) => boolean, checkboxDisabled: (e: T | N, isNested?: boolean) => boolean, strategy?: TSelectionStrategy) => SelectionState;

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

@@ -1,28 +1,64 @@
+import { getChildrenForSelection } from "../../../commonHelpers/showMoreRow";
 import { SelectionState } from "../interfaces";
 export const calculateSelectionState = (entities, selections, all, checkboxVisible, checkboxDisabled, strategy) => {
     if (selections.size === 0) {
         return all ? SelectionState.All : SelectionState.None;
     }
+    if (all) {
+        // When `all` is true, `selections` holds the ids explicitly excluded from the
+        // otherwise-fully-selected set (see ISelectionValue), rather than included ids.
+        const isExcluded = (entity) => {
+            const children = strategy === "nested" ? getChildrenForSelection(entity) : undefined;
+            if (children && children.length > 0) {
+                return children.every(child => {
+                    if (!checkboxVisible(child, true)) {
+                        return true;
+                    }
+                    if (checkboxDisabled(child, true)) {
+                        return true;
+                    }
+                    return selections.has(child.id);
+                });
+            }
+            return selections.has(entity.id);
+        };
+        const isPartiallyExcluded = (entity) => {
+            const children = strategy === "nested" ? getChildrenForSelection(entity) : undefined;
+            if (children && children.length > 0) {
+                return children.some(child => selections.has(child.id));
+            }
+            return selections.has(entity.id);
+        };
+        const relevantEntities = entities.filter(entity => checkboxVisible(entity, false) && !checkboxDisabled(entity, false));
+        if (relevantEntities.length === 0) {
+            return SelectionState.All;
+        }
+        if (relevantEntities.every(entity => !isPartiallyExcluded(entity))) {
+            return SelectionState.All;
+        }
+        return relevantEntities.every(entity => isExcluded(entity)) ? SelectionState.None : SelectionState.Partial;
+    }
     return entities.every(entity => {
-        if (!checkboxVisible(entity)) {
+        if (!checkboxVisible(entity, false)) {
             return true;
         }
-        if (checkboxDisabled(entity)) {
+        if (checkboxDisabled(entity, false)) {
             return true;
         }
         if (strategy === "nested") {
-            if (entity.children) {
-                return entity.children.every(child => {
-                    if (!checkboxVisible(child)) {
+            const children = getChildrenForSelection(entity);
+            if (children && children.length > 0) {
+                return children.every(child => {
+                    if (!checkboxVisible(child, true)) {
                         return true;
                     }
-                    if (checkboxDisabled(child)) {
+                    if (checkboxDisabled(child, true)) {
                         return true;
                     }
                     return selections.has(child.id);
                 });
             }
-            return false;
+            return selections.has(entity.id);
         }
         return selections.has(entity.id);
     })

package/esm/table/selectable/utils/checkRow.js

@@ -1,9 +1,11 @@
+import { getChildrenForSelection } from "../../../commonHelpers/showMoreRow";
 export const checkRow = (selectionSet, selectable, entities, id, checked) => {
     const setValue = (rowId) => (checked ? selectionSet.add(rowId) : selectionSet.delete(rowId));
     if ((selectable === null || selectable === void 0 ? void 0 : selectable.strategy) === "nested") {
         const entity = entities.find(e => e.id === id);
-        if (entity && entity.children && entity.children.length > 0) {
-            entity.children.forEach(child => {
+        const children = entity ? getChildrenForSelection(entity) : undefined;
+        if (entity && children && children.length > 0) {
+            children.forEach(child => {
                 const isChildVisible = selectable.checkboxVisible ? selectable.checkboxVisible(child, true) : true;
                 const isChildEnabled = !selectable.checkboxDisabled || !selectable.checkboxDisabled(child, true);
                 if (isChildVisible && isChildEnabled) {

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

@@ -1,12 +1,16 @@
+import { getChildrenForSelection, isShowMoreRow } from "../../../commonHelpers/showMoreRow";
 export const getCurrentPageSelection = (entities, selectable) => {
     const newSelections = new Set();
     entities.forEach(entity => {
-        const isVisible = (selectable === null || selectable === void 0 ? void 0 : selectable.checkboxVisible) ? selectable.checkboxVisible(entity) : true;
+        const isVisible = !entity.isLoading && !isShowMoreRow(entity) && ((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);
-        if ((selectable === null || selectable === void 0 ? void 0 : selectable.strategy) === "nested") {
-            (entity.children || []).forEach(child => {
-                const isChildVisible = selectable.checkboxVisible ? selectable.checkboxVisible(child, true) : true;
-                const isChildEnabled = !selectable.checkboxDisabled || !selectable.checkboxDisabled(child, true);
+        const children = (selectable === null || selectable === void 0 ? void 0 : selectable.strategy) === "nested" ? getChildrenForSelection(entity) : undefined;
+        if (children && children.length > 0) {
+            children.forEach(child => {
+                const isChildVisible = !child.isLoading &&
+                    !isShowMoreRow(child) &&
+                    ((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/esm/table/selectable/utils/getDragSelectionRows.d.ts

@@ -0,0 +1,15 @@
+import { IEntityWithId } from "../../../commonHelpers/entity";
+import { IRowEntity } from "../../../dataGrid/row/row";
+import { IDragSelectionRow } from "../interfaces";
+export interface IDragSelection<T> {
+    /** The rows in render order. */
+    rows: IDragSelectionRow[];
+    /** Every entity a row can point at, parents and children alike. */
+    entityById: Map<string, T>;
+}
+/**
+ * Flattens the entities into the rows the grid actually renders: each entity followed by its
+ * children while it is expanded. Drag and shift-click ranges walk this list, so they cross
+ * nesting levels the way the user sees them on screen.
+ */
+export declare const getDragSelectionRows: <T extends IRowEntity<N>, N extends IEntityWithId>(entities: T[], expandedRows?: string[]) => IDragSelection<T | N>;

package/esm/table/selectable/utils/getDragSelectionRows.js

@@ -0,0 +1,24 @@
+/**
+ * Flattens the entities into the rows the grid actually renders: each entity followed by its
+ * children while it is expanded. Drag and shift-click ranges walk this list, so they cross
+ * nesting levels the way the user sees them on screen.
+ */
+export const getDragSelectionRows = (entities, expandedRows) => {
+    const expanded = new Set(expandedRows);
+    const rows = [];
+    const entityById = new Map();
+    entities.forEach(entity => {
+        rows.push({ id: entity.id, isNested: false });
+        entityById.set(entity.id, entity);
+        // Children are always indexed — a collapsed row's children still need to resolve for
+        // the selection predicates — but only an expanded row contributes them to the range.
+        const isExpanded = expanded.has(entity.id);
+        (entity.children || []).forEach(child => {
+            entityById.set(child.id, child);
+            if (isExpanded) {
+                rows.push({ id: child.id, isNested: true });
+            }
+        });
+    });
+    return { rows, entityById };
+};

package/esm/table/selectable/utils/getRangeIds.d.ts

@@ -0,0 +1,2 @@
+import { IDragSelectionRow } from "../interfaces";
+export declare const getRangeIds: (rows: IDragSelectionRow[], fromId: string, toId: string, isSelectable: (row: IDragSelectionRow) => boolean) => string[];

package/esm/table/selectable/utils/getRangeIds.js

@@ -0,0 +1,17 @@
+export const getRangeIds = (rows, fromId, toId, isSelectable) => {
+    const fromIdx = rows.findIndex(row => row.id === fromId);
+    const toIdx = rows.findIndex(row => row.id === toId);
+    if (fromIdx === -1 || toIdx === -1) {
+        return [];
+    }
+    const start = Math.min(fromIdx, toIdx);
+    const end = Math.max(fromIdx, toIdx);
+    const ids = [];
+    for (let i = start; i <= end; i++) {
+        const row = rows[i];
+        if (isSelectable(row)) {
+            ids.push(row.id);
+        }
+    }
+    return ids;
+};

package/esm/table/selectable/utils/isRowChecked.d.ts

@@ -2,7 +2,7 @@ import { IEntityWithId } from "../../../commonHelpers/entity";
 import { IRowEntity } from "../../../dataGrid/row/row";
 import { SelectionState } from "../interfaces";
 import { TSelectionStrategy } from "../useSelectableRows";
-export declare const isRowChecked: <T extends IRowEntity<N>, N extends IEntityWithId>(selections: Set<string>, state: SelectionState, strategy: TSelectionStrategy | undefined, entity: T | N, isNested: boolean) => {
+export declare const isRowChecked: <T extends IRowEntity<N>, N extends IEntityWithId>(selections: Set<string>, state: SelectionState, strategy: TSelectionStrategy | undefined, entity: T | N, isNested: boolean, checkboxVisible?: (e: T | N, isNested?: boolean) => boolean, checkboxDisabled?: (e: T | N, isNested?: boolean) => boolean) => {
     indeterminate: boolean;
     checked: boolean;
 };

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

@@ -1,16 +1,49 @@
+import { getChildrenForSelection } from "../../../commonHelpers/showMoreRow";
 import { SelectionState } from "../interfaces";
-export const isRowChecked = (selections, state, strategy, entity, isNested) => {
+// The full, un-capped children list, so children hidden behind a "+N more" row still count
+// towards the parent checkbox state.
+const getNestedChildren = (entity, strategy) => strategy === "nested" ? getChildrenForSelection(entity) : undefined;
+// Children the parent checkbox can actually act on - the consumer may hide or disable some.
+const filterSelectable = (children, checkboxVisible, checkboxDisabled) => children.filter(child => {
+    if (checkboxVisible && !checkboxVisible(child, true)) {
+        return false;
+    }
+    if (checkboxDisabled && checkboxDisabled(child, true)) {
+        return false;
+    }
+    return true;
+});
+export const isRowChecked = (selections, state, strategy, entity, isNested, checkboxVisible, checkboxDisabled) => {
     if (state === SelectionState.All) {
-        return { indeterminate: false, checked: true };
+        // When the overall selection is "all", `selections` holds the ids that have been
+        // explicitly excluded from that selection (see ISelectionValue), not included ids.
+        if (isNested) {
+            return { indeterminate: false, checked: !selections.has(entity.id) };
+        }
+        const children = getNestedChildren(entity, strategy);
+        if (children && children.length > 0) {
+            const selectableChildren = filterSelectable(children, checkboxVisible, checkboxDisabled);
+            if (selectableChildren.length === 0) {
+                return { indeterminate: false, checked: true };
+            }
+            const allChildrenChecked = selectableChildren.every(child => !selections.has(child.id));
+            const someChildrenChecked = selectableChildren.some(child => !selections.has(child.id));
+            return { indeterminate: someChildrenChecked && !allChildrenChecked, checked: allChildrenChecked };
+        }
+        return { indeterminate: false, checked: !selections.has(entity.id) };
     }
     if (isNested) {
         return { indeterminate: false, checked: selections.has(entity.id) };
     }
-    const mainEntity = entity;
-    if (strategy === "nested" && mainEntity.children && mainEntity.children.length > 0) {
-        const allChildrenSelected = mainEntity.children.every(child => selections.has(child.id));
-        const someChildrenSelected = mainEntity.children.some(child => selections.has(child.id));
-        return { indeterminate: someChildrenSelected, checked: allChildrenSelected };
+    const children = getNestedChildren(entity, strategy);
+    if (children && children.length > 0) {
+        const selectableChildren = filterSelectable(children, checkboxVisible, checkboxDisabled);
+        if (selectableChildren.length === 0) {
+            return { indeterminate: false, checked: false };
+        }
+        const allChildrenSelected = selectableChildren.every(child => selections.has(child.id));
+        const someChildrenSelected = selectableChildren.some(child => selections.has(child.id));
+        return { indeterminate: someChildrenSelected && !allChildrenSelected, checked: allChildrenSelected };
     }
     return { indeterminate: false, checked: selections.has(entity.id) };
 };

package/esm/table/table.d.ts

@@ -1,6 +1,6 @@
 import { IZenComponentProps, IZenGridItem } from "../commonHelpers/zenComponent";
 import { ReactNode } from "react";
-import { ISelectableRowsOptions } from "./selectable/useSelectableRows";
+import { getEmptySelection, ISelectableRowsOptions } from "./selectable/useSelectableRows";
 import { ISortableOptions } from "./sortable/useSortableColumns";
 import { IFlexibleColumnsOptions } from "./flexible/useFlexibleColumns";
 import { IColumnComponent, IListColumnWrapper } from "../dataGrid/listColumn";
@@ -11,7 +11,6 @@ import { ITablePagination, TablePagination } from "./children/tablePagination";
 import { ITableEmpty, TableEmpty } from "./children/tableEmpty";
 import { ITableFooter, TableFooter } from "./children/tableFooter";
 import "./table.less";
-import { getEmptySelection } from "./selectable/useSelectableRows";
 import { ColumnSortDirection } from "./sortable/interfaces";
 import { getSortableValue } from "./sortable/useSortableColumns";
 import { ActionsColumn } from "../dataGrid/columns/actionsColumn/actionsColumn";