lightning-base-components 1.27.2-alpha → 1.27.5-alpha

package/src/lightning/datatable/rowSelection.js

@@ -12,14 +12,20 @@ import {
 import { isNonNegativeInteger } from './utils';
 import {
     getCurrentSelectionLength,
+    getRemainingEditSlots,
+    getRowsKeys,
     getSelectedRowsKeys,
-    isDisabledRow,
     isInputTypeCheckbox,
     SELECTABLE_HEADER_TYPE,
     SINGLE_ROW_SELECTION_MODES,
+    setDisabledRows,
+    isDisabledRow,
+    getCurrentEditedRowsCount,
 } from './rowSelectionShared';
-import { normalizeString } from 'lightning/utilsPrivate';
+import { normalizeString, isUndefinedOrNull } from 'lightning/utilsPrivate';
 import { setInliningProperties } from './rowsInlining';
+import { features } from 'lightning/features';
+import { updateCells } from './rows';
 
 const MAX_ROW_SELECTION_DEFAULT = undefined;
 
@@ -30,7 +36,30 @@ const ROWS_ACTION = {
     ROW_DESELECT: 'rowDeselect',
 };
 
-/************************** EVENT HANDLERS **************************/
+/** ************************ HELPER FUNCTIONS **************************/
+
+/**
+ * Determines if selecting a row would count as a "new edit selection"
+ * that should be counted against the maxEditLimit.
+ * Returns false if maxEditLimit feature is disabled or if the row
+ * was already selected or edited.
+ *
+ * @param {Object} state The datatable state
+ * @param {String} rowKeyValue The row key value to check
+ * @returns {Boolean} Whether this would be a new edit selection
+ */
+function isNewEditSelection(state, rowKeyValue) {
+    if (!features.enableMaxEditLimit) {
+        return false;
+    }
+
+    const wasAlreadySelected = !!state.selectedRowsKeys[rowKeyValue];
+    const isAlreadyEdited = !!state.inlineEdit?.dirtyValues?.[rowKeyValue];
+
+    return !wasAlreadySelected && !isAlreadyEdited;
+}
+
+/** ************************ EVENT HANDLERS **************************/
 
 /**
  * Marks all possible rows as selected depending on the max-row-selection value.
@@ -53,7 +82,7 @@ export function handleSelectAllRows(event) {
  */
 export function handleDeselectAllRows(event) {
     event.stopPropagation();
-    markAllRowsDeselected(this.state);
+    markAllRowsDeselected(this.state, false);
     this.fireSelectedRowsChange(this.getSelectedRows(), {
         action: ROWS_ACTION.DESELECT_ALL_ROWS,
     });
@@ -114,7 +143,7 @@ export function handleRowSelectionChange() {
     updateBulkSelectionState(this.state);
 }
 
-/************************** ROW SELECTION **************************/
+/** ************************ ROW SELECTION **************************/
 
 /**
  * Marks all rows as selected.
@@ -125,41 +154,91 @@ export function handleRowSelectionChange() {
  *        row is selected on each row object.
  *     2. If max-row-selection has been reached, mark the remaining rows
  *        to reflect that they are not selected and disable them.
+ *     3. If max-edit-limit would be exceeded, dont select additional rows.
  *
  * @param {Object} state - The datatable state
  */
 export function markAllRowsSelected(state) {
-    const { maxRowSelection, rows } = state;
-    const selectedRowsKeys = {};
+    const { enableDisabledRowsAttribute } = features;
+    const { disabledRowsKeys, maxRowSelection, rows, selectedRowsKeys } = state;
+    const newSelectedRowsKeys = {};
+    // Used to ensure that rows that are both disabled
+    // and selected are counted in maxRowSelection
+    let numRowsSelected = getDisabledAndSelectedRowCount(state);
+
+    const remainingEditSlots = getRemainingEditSlots(state);
+    let newSelectionsCount = 0;
+
     for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
         const row = rows[i];
-        if (maxRowSelection === undefined || i < maxRowSelection) {
-            selectedRowsKeys[row.key] = true;
+        const selectedRowsCounter = enableDisabledRowsAttribute
+            ? numRowsSelected
+            : i;
+
+        if (enableDisabledRowsAttribute && disabledRowsKeys[row.key]) {
+            if (selectedRowsKeys[row.key]) {
+                newSelectedRowsKeys[row.key] = true;
+            }
+        } else if (
+            (maxRowSelection === undefined ||
+                selectedRowsCounter < maxRowSelection) &&
+            (!isNewEditSelection(state, row.key) ||
+                newSelectionsCount < remainingEditSlots)
+        ) {
+            newSelectedRowsKeys[row.key] = true;
             setRowSelectedAttributes(row, true);
+            if (enableDisabledRowsAttribute) {
+                numRowsSelected += 1;
+            }
+            // count this as a new selection only if it wasn't already selected or edited
+            if (isNewEditSelection(state, row.key)) {
+                newSelectionsCount += 1;
+            }
         } else {
             row.isDisabled = true;
             setRowSelectedAttributes(row, false);
         }
     }
-    state.selectedRowsKeys = selectedRowsKeys;
+    state.selectedRowsKeys = newSelectedRowsKeys;
 }
 
 /**
- * Marks all rows as de-selected.
+ * Marks all rows as de-selected. If `deselectDisabledRows` is set to false,
+ * disabled rows will not be de-selected.
+ *
  * Retrieve all rows from the state object. Iterate over these rows; for each row
  * set `isSelected` and `ariaSelected` to false and enable the row. Also resolve
  * the `classnames` for the row to reflect that it is not selected.
  *
  * @param {Object} state - The datatable state
+ * @param {boolean} deselectDisabledRows - only deselect disabled rows when this is true
  */
-export function markAllRowsDeselected(state) {
-    const { rows } = state;
+export function markAllRowsDeselected(state, deselectDisabledRows = true) {
+    const { enableDisabledRowsAttribute } = features;
+    const { disabledRowsKeys, rows, selectedRowsKeys } = state;
+    const newSelectedRowsKeys = {};
     for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
         const row = rows[i];
-        row.isDisabled = false;
-        setRowSelectedAttributes(row, false);
+        if (!enableDisabledRowsAttribute) {
+            row.isDisabled = false;
+            setRowSelectedAttributes(row, false);
+        } else {
+            // Programmatically disabled rows should stay disabled but rows
+            // disabled after meeting max-row-selection should be re-enabled
+            const shouldEnable = !disabledRowsKeys[row.key];
+            if (shouldEnable || deselectDisabledRows) {
+                if (shouldEnable) {
+                    row.isDisabled = false;
+                }
+                setRowSelectedAttributes(row, false);
+            } else if (!shouldEnable && selectedRowsKeys[row.key]) {
+                // When clicking checkbox to deselect all rows, rows that are
+                // both disabled and selected should stay disabled and selected
+                newSelectedRowsKeys[row.key] = true;
+            }
+        }
     }
-    state.selectedRowsKeys = {};
+    state.selectedRowsKeys = newSelectedRowsKeys;
 }
 
 /**
@@ -181,13 +260,17 @@ export function markAllRowsDeselected(state) {
  * @param {String} endRowKey - row key value of the last row that was selected (end of the interval)
  */
 function markSelectedRowsInterval(state, startRowKey, endRowKey) {
-    const { rows } = state;
+    const { enableDisabledRowsAttribute } = features;
+    const { disabledRowsKeys, rows } = state;
     const { start, end } = getRowIntervalIndexes(state, startRowKey, endRowKey);
     const total = state.maxRowSelection || rows.length;
     let rowIndex = start;
     let maxSelectionReached;
     while (rowIndex <= end && !maxSelectionReached) {
-        markRowSelected(state, rows[rowIndex].key);
+        const { key } = rows[rowIndex];
+        if (!enableDisabledRowsAttribute || !disabledRowsKeys[key]) {
+            markRowSelected(state, key);
+        }
         maxSelectionReached = getCurrentSelectionLength(state) >= total;
         rowIndex += 1;
     }
@@ -211,14 +294,17 @@ function markSelectedRowsInterval(state, startRowKey, endRowKey) {
  * @param {String} endRowKey - row key value of the last row that was selected (end of the interval)
  */
 function markDeselectedRowsInterval(state, startRowKey, endRowKey) {
-    const { rows, selectedRowsKeys } = state;
+    const { enableDisabledRowsAttribute } = features;
+    const { disabledRowsKeys, rows, selectedRowsKeys } = state;
     const { start, end } = getRowIntervalIndexes(state, startRowKey, endRowKey);
 
     for (let rowIndex = start; rowIndex <= end; rowIndex += 1) {
         const row = rows[rowIndex];
-        setRowSelectedAttributes(row, false);
-        // Setting to `false` instead of using `delete` for better performance.
-        selectedRowsKeys[row.key] = false;
+        if (!enableDisabledRowsAttribute || !disabledRowsKeys[row.key]) {
+            setRowSelectedAttributes(row, false);
+            // Setting to `false` instead of using `delete` for better performance.
+            selectedRowsKeys[row.key] = false;
+        }
         if (getCurrentSelectionLength(state) === state.maxRowSelection - 1) {
             markDeselectedRowEnabled(state);
         }
@@ -248,7 +334,8 @@ export function markRowSelected(state, rowKeyValue) {
 
     setRowSelectedAttributes(row, true);
 
-    let { selectedRowsKeys, singleRowSelectionMode } = state;
+    let { selectedRowsKeys } = state;
+    const { singleRowSelectionMode } = state;
     if (
         total > 1 ||
         (total === 1 &&
@@ -312,15 +399,21 @@ function markRowsDeselectedByKeys(state, keys) {
  * from selecting any more rows.
  * This is typically called once the selection has reached the
  * max-row-selection value and no more rows are allowed to be selected.
+ * Also considers max-edit-limit constraints.
  *
  * @param {Object} state - datatable's state object
  */
 export function markDeselectedRowDisabled(state) {
-    const { rows, selectedRowsKeys } = state;
-    for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
-        const row = rows[i];
-        if (!selectedRowsKeys[row.key]) {
-            row.isDisabled = true;
+    if (features.enableMaxEditLimit) {
+        setDisabledRows(state);
+    } else {
+        // only disable unselected rows
+        const { rows, selectedRowsKeys } = state;
+        for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
+            const row = rows[i];
+            if (!selectedRowsKeys[row.key]) {
+                row.isDisabled = true;
+            }
         }
     }
 }
@@ -331,20 +424,158 @@ export function markDeselectedRowDisabled(state) {
  * This is typically called when the maximum number of rows were
  * previously selected but a row was deselected, now allowing
  * any other row to be selected - for this, all rows should be enabled
+ * based on current selection and edit limits.
  *
  * @param {Object} state - The datatable state
  */
 export function markDeselectedRowEnabled(state) {
-    const { rows, selectedRowsKeys } = state;
+    const { enableDisabledRowsAttribute, enableMaxEditLimit } = features;
+
+    if (enableMaxEditLimit) {
+        setDisabledRows(state);
+    } else {
+        // only enable unselected rows
+        const { rows, selectedRowsKeys, disabledRowsKeys } = state;
+        for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
+            const row = rows[i];
+            if (enableDisabledRowsAttribute) {
+                if (!selectedRowsKeys[row.key] && !disabledRowsKeys[row.key]) {
+                    row.isDisabled = false;
+                }
+            } else if (!selectedRowsKeys[row.key]) {
+                row.isDisabled = false;
+            }
+        }
+    }
+}
+
+/** ************************ DISABLED ROW KEYS **************************/
+
+/**
+ * This is called when the `disabled-rows` attribute is set on the datatable
+ * The 'value' parameter should be an Array of key-field values. If it is not an array,
+ * we throw an error stating so and all rows are de-selected.
+ *
+ * If the 'value' param is valid, we filter the 'value' array for only the valid keys.
+ *
+ * Compute the differences between the currently disabled rows vs
+ * the newly disabled rows to find out which rows need to be additionally
+ * disabled and re-enabled.
+ * Based on the above computation, mark rows as disabled or enabled and
+ * set the new `disabledRowsKeys` in the state object.
+ *
+ * @param {Object} state - The datatable state
+ * @param {Array} value - key-field values of rows to set as disabled
+ */
+export function setDisabledRowsKeys(state, value) {
+    if (Array.isArray(value)) {
+        const disabledRows = filterValidKeys(state, value);
+        updateDisabledRowsByKeys(state, disabledRows);
+    } else {
+        // eslint-disable-next-line no-console
+        console.error(
+            `The "disabled-rows" passed into "lightning-datatable" must be an Array with the keys of the disabled rows. We instead received ${value}`
+        );
+        markAllRowsEnabled(state);
+    }
+    updateBulkSelectionState(state);
+    // If using radio buttons and a row is both selected
+    // and disabled, disable all the other radio buttons
+    if (isSelectedRadioDisabled(state)) {
+        markDeselectedRowDisabled(state);
+    }
+}
+
+function updateDisabledRowsByKeys(state, newKeysArr) {
+    const newKeysObj = {};
+    const { disabledRowsKeys: oldKeysObj } = state;
+    // Disable rows unique to newKeysArr
+    for (let i = 0, { length } = newKeysArr; i < length; i += 1) {
+        const rowKeyValue = newKeysArr[i];
+        newKeysObj[rowKeyValue] = true;
+        if (!oldKeysObj[rowKeyValue]) {
+            const row = getRowByKey(state, rowKeyValue);
+            if (row) {
+                row.isDisabled = true;
+            }
+        }
+    }
+    // Enable rows unique to oldKeysObj
+    const oldKeysArr = Object.keys(oldKeysObj);
+    for (let i = 0, { length } = oldKeysArr; i < length; i += 1) {
+        const rowKeyValue = oldKeysArr[i];
+        if (oldKeysObj[rowKeyValue] && !newKeysObj[rowKeyValue]) {
+            const row = getRowByKey(state, rowKeyValue);
+            if (row) {
+                row.isDisabled = false;
+            }
+        }
+    }
+    state.disabledRowsKeys = newKeysObj;
+}
+
+function markAllRowsEnabled(state) {
+    const { rows } = state;
     for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
         const row = rows[i];
-        if (!selectedRowsKeys[row.key]) {
-            row.isDisabled = false;
+        row.isDisabled = false;
+    }
+    state.disabledRowsKeys = {};
+}
+
+function getDisabledRowCount(state) {
+    if (!features.enableDisabledRowsAttribute) {
+        return 0;
+    }
+    const { disabledRowsKeys } = state;
+    const keys = Object.keys(disabledRowsKeys);
+    let disabledCount = 0;
+    for (let i = 0; i < keys.length; i += 1) {
+        const key = keys[i];
+        if (disabledRowsKeys[key]) {
+            disabledCount += 1;
+        }
+    }
+    return disabledCount;
+}
+
+function getDisabledAndSelectedRowCount(state) {
+    if (!features.enableDisabledRowsAttribute) {
+        return 0;
+    }
+    const { disabledRowsKeys, selectedRowsKeys } = state;
+    const keys = Object.keys(disabledRowsKeys);
+    let disabledAndSelectedCount = 0;
+    for (let i = 0; i < keys.length; i += 1) {
+        const key = keys[i];
+        if (disabledRowsKeys[key] && selectedRowsKeys[key]) {
+            disabledAndSelectedCount += 1;
         }
     }
+    return disabledAndSelectedCount;
+}
+
+function allRowsDisabled(state) {
+    if (!features.enableDisabledRowsAttribute) {
+        return false;
+    }
+    const { rows } = state;
+    const numRows = rows.length;
+    const numDisabledRows = getDisabledRowCount(state);
+    return numRows === numDisabledRows;
+}
+
+function isSelectedRadioDisabled(state) {
+    if (!features.enableDisabledRowsAttribute) {
+        return false;
+    }
+    return (
+        !isInputTypeCheckbox(state) &&
+        getDisabledAndSelectedRowCount(state) === 1
+    );
 }
 
-/************************** SELECTED ROW KEYS **************************/
+/** ************************ SELECTED ROW KEYS **************************/
 
 /**
  * This is called when the `selected-rows` attribute is set on the datatable
@@ -382,6 +613,31 @@ export function setSelectedRowsKeys(state, value) {
             selectedRows = selectedRows.slice(0, maxRowSelection);
         }
 
+        // check if max-edit-limit would be exceeded
+        if (
+            features.enableMaxEditLimit &&
+            !isUndefinedOrNull(state.maxEditLimit)
+        ) {
+            const currentEditedRowsCount = getCurrentEditedRowsCount(state);
+            const maxEditableRows = state.maxEditLimit;
+
+            // if adding these selections would exceed the limit, trim the selection
+            if (
+                currentEditedRowsCount + selectedRows.length >
+                maxEditableRows
+            ) {
+                // eslint-disable-next-line no-console
+                console.warn(
+                    `The number of selected rows would exceed the limit defined by maxEditLimit (${maxEditableRows}).`
+                );
+                // just take as many rows as we can up to the limit
+                selectedRows = selectedRows.slice(
+                    0,
+                    Math.max(0, maxEditableRows - currentEditedRowsCount)
+                );
+            }
+        }
+
         // Convert the selectedRows Array to an Object that state.selectedRowKeys expects
         // ['a', 'b'] -> { a : true, b : true}
         const selectedRowsKeys = normalizeSelectedRowsKey(selectedRows);
@@ -403,8 +659,9 @@ export function setSelectedRowsKeys(state, value) {
         // If we select the max number of rows allowed and if max-row-selection > 1 (multi-select),
         // disable all the other rows to prevent further selection
         if (
-            selectedRowsCount === maxRowSelection &&
-            isInputTypeCheckbox(state)
+            (selectedRowsCount === maxRowSelection &&
+                isInputTypeCheckbox(state)) ||
+            isSelectedRadioDisabled(state)
         ) {
             markDeselectedRowDisabled(state);
         } else if (
@@ -503,7 +760,7 @@ function filterValidKeys(state, keys) {
     return filtered;
 }
 
-/************************** LAST SELECTED ROW KEYS **************************/
+/** ************************ LAST SELECTED ROW KEYS **************************/
 
 /**
  * Returns the row key value of the row that was last selected
@@ -521,7 +778,7 @@ function getLastRowSelection(state) {
     return keyIsValid ? lastSelectedRowKey : undefined;
 }
 
-/************************** INPUT TYPES **************************/
+/** ************************ INPUT TYPES **************************/
 
 /**
  * Computes whether or not the input type rendered for row selection needs to change
@@ -570,23 +827,27 @@ export function updateRowSelectionInputType(state, datatableId) {
         checkboxColIndex = state.showRowNumberColumn ? 1 : 0;
     }
 
-    for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
-        // Tracked state changes.
-        const row = rows[i];
-        row.inputType = type;
-        row.isDisabled = isDisabledRow(state, row.key);
-        if (resetInliningProps) {
-            setInliningProperties(
-                state,
-                row.cells[checkboxColIndex],
-                isCheckbox,
-                datatableId
-            );
+    if (features.enableMaxEditLimit) {
+        setDisabledRows(state);
+    } else {
+        for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
+            // Tracked state changes.
+            const row = rows[i];
+            row.inputType = type;
+            row.isDisabled = isDisabledRow(state, row.key);
+            if (resetInliningProps) {
+                setInliningProperties(
+                    state,
+                    row.cells[checkboxColIndex],
+                    isCheckbox,
+                    datatableId
+                );
+            }
         }
     }
 }
 
-/************************** MAX ROW SELECTION **************************/
+/** ************************ MAX ROW SELECTION **************************/
 
 /**
  * Sets maxRowSelection to the provided value,
@@ -600,7 +861,12 @@ export function updateRowSelectionInputType(state, datatableId) {
  * @param {Number | String} - value to set for maxRowSelection
  */
 export function setMaxRowSelection(state, value, datatableId) {
-    const previousSelectedRowsKeys = getSelectedRowsKeys(state);
+    let previousSelectedRowsKeys;
+    if (features.enableDisabledRowsAttribute) {
+        previousSelectedRowsKeys = getRowsKeys(state.selectedRowsKeys);
+    } else {
+        previousSelectedRowsKeys = getSelectedRowsKeys(state);
+    }
     // Tracked state changes.
     markAllRowsDeselected(state);
     if (isNonNegativeInteger(value)) {
@@ -623,6 +889,11 @@ export function setMaxRowSelection(state, value, datatableId) {
             // Tracked state changes.
             updateRowSelectionInputType(state, datatableId);
             updateBulkSelectionState(state);
+            // If changed to radio buttons, may need to disable
+            // all rows if a row is both selected and disabled
+            if (isSelectedRadioDisabled(state)) {
+                markDeselectedRowDisabled(state);
+            }
         }
     } else {
         // Untracked state change.
@@ -637,7 +908,7 @@ export function setMaxRowSelection(state, value, datatableId) {
     }
 }
 
-/************************** SINGLE ROW SELECTION MODE **************************/
+/** ************************ SINGLE ROW SELECTION MODE **************************/
 
 /**
  * Sets singleRowSelectionMode to the provided value.
@@ -665,7 +936,7 @@ export function setSingleRowSelectionMode(state, value, datatableId) {
     }
 }
 
-/************************** BULK SELECTION STATE **************************/
+/** ************************ BULK SELECTION STATE **************************/
 
 export function updateBulkSelectionState(state) {
     const columns = state.columns || {};
@@ -676,21 +947,32 @@ export function updateBulkSelectionState(state) {
                 maxRowSelection,
                 rows: { length: rowCount },
             } = state;
-            const total =
-                maxRowSelection && maxRowSelection < rowCount
-                    ? maxRowSelection
-                    : rowCount;
+            const total = getMaxSelectableRows(state);
+            const maxSelectableForLabel = getMaxSelectableRows(state);
             const selected = getCurrentSelectionLength(state);
+            const selectedAndDisabled = getDisabledAndSelectedRowCount(state);
             // Force a rerender of this column by replacing the tracked object.
             // Required to pass treegrid unit tests.
             const updatedCol = Object.assign({}, col);
             if (selected) {
+                // Bulk selection action depends on whether or not any
+                // enabled rows are selected - disabled rows not considered
+                if (selected - selectedAndDisabled) {
+                    updatedCol.enabledRowsSelected = true;
+                } else {
+                    updatedCol.enabledRowsSelected = false;
+                }
                 updatedCol.bulkSelection = selected === total ? 'all' : 'some';
             } else {
                 updatedCol.bulkSelection = 'none';
+                updatedCol.enabledRowsSelected = false;
             }
             updatedCol.isBulkSelectionDisabled =
-                maxRowSelection === 0 || rowCount === 0;
+                maxRowSelection === 0 ||
+                rowCount === 0 ||
+                allRowsDisabled(state);
+            // Set the max selectable rows for the header label
+            updatedCol.maxSelectableRows = maxSelectableForLabel;
             // Replace old column with shallow cloned and updated column.
             columns[colIndex] = updatedCol;
             return;
@@ -698,7 +980,7 @@ export function updateBulkSelectionState(state) {
     }
 }
 
-/************************** HELPER FUNCTIONS **************************/
+/** ************************ HELPER FUNCTIONS **************************/
 
 /**
  * Gets the interval of row indexes based on the start and end row key values
@@ -799,3 +1081,39 @@ function getDeselectedDiff(state, value) {
     }
     return filtered;
 }
+
+export function updateRowDisabledStatesForEditLimit(state, types) {
+    if (
+        !features.enableMaxEditLimit ||
+        isUndefinedOrNull(state.maxEditLimit) ||
+        !state.rows?.length
+    ) {
+        return;
+    }
+
+    setDisabledRows(state);
+    updateCells(state, types);
+}
+
+export function getMaxSelectableRows(state) {
+    const {
+        maxRowSelection,
+        rows: { length: rowCount },
+    } = state;
+    let maxSelectable = rowCount;
+    // Account for disabled rows if feature is enabled
+    if (features.enableDisabledRowsAttribute) {
+        const disabledCount = getDisabledRowCount(state);
+        const disabledAndSelectedCount = getDisabledAndSelectedRowCount(state);
+        maxSelectable = rowCount - disabledCount + disabledAndSelectedCount;
+    }
+    // Apply maxRowSelection constraint
+    if (!isUndefinedOrNull(maxRowSelection)) {
+        maxSelectable = Math.min(maxSelectable, maxRowSelection);
+    }
+    // Apply maxEditLimit constraint if enabled
+    if (features.enableMaxEditLimit && !isUndefinedOrNull(state.maxEditLimit)) {
+        maxSelectable = Math.min(maxSelectable, state.maxEditLimit);
+    }
+    return Math.max(0, maxSelectable);
+}