lightning-base-components 1.27.5-alpha → 1.28.3-alpha

package/src/lightning/datatable/rowSelection.js

@@ -3,70 +3,28 @@
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-import {
-    getCellByKeys,
-    getRowByKey,
-    getRowIndexByKey,
-    HEADER_ROW_KEY,
-} from './indexes';
+import { getCellByKeys, getRowByKey, getRowIndexByKey, HEADER_ROW_KEY, } from './indexes';
 import { isNonNegativeInteger } from './utils';
-import {
-    getCurrentSelectionLength,
-    getRemainingEditSlots,
-    getRowsKeys,
-    getSelectedRowsKeys,
-    isInputTypeCheckbox,
-    SELECTABLE_HEADER_TYPE,
-    SINGLE_ROW_SELECTION_MODES,
-    setDisabledRows,
-    isDisabledRow,
-    getCurrentEditedRowsCount,
-} from './rowSelectionShared';
+import { getCurrentSelectionLength, getRemainingEditSlots, getRowsKeys, getSelectedRowsKeys, isInputTypeCheckbox, SELECTABLE_HEADER_TYPE, SINGLE_ROW_SELECTION_MODES, setDisabledRows, isDisabledRow, getCurrentEditedRowsCount, } from './rowSelectionShared';
 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;
-
 const ROWS_ACTION = {
     SELECT_ALL_ROWS: 'selectAllRows',
     DESELECT_ALL_ROWS: 'deselectAllRows',
     ROW_SELECT: 'rowSelect',
     ROW_DESELECT: 'rowDeselect',
 };
-
-/** ************************ 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.
- * Fires the `rowselection` event with the new set of selected rows.
- *
- * @param {CustomEvent} event - `selectallrows`
- */
 export function handleSelectAllRows(event) {
     event.stopPropagation();
     markAllRowsSelected(this.state);
@@ -74,12 +32,6 @@ export function handleSelectAllRows(event) {
         action: ROWS_ACTION.SELECT_ALL_ROWS,
     });
 }
-
-/**
- * Marks all rows as de-selected. Does not need to account for max-row-selection.
- * Fires the `rowselection` event with the new set of selected rows.
- * @param {CustomEvent} event - `deselectallrows`
- */
 export function handleDeselectAllRows(event) {
     event.stopPropagation();
     markAllRowsDeselected(this.state, false);
@@ -87,16 +39,6 @@ export function handleDeselectAllRows(event) {
         action: ROWS_ACTION.DESELECT_ALL_ROWS,
     });
 }
-
-/**
- * Handles selection of row(s)
- * 1. Marks the relevant rows as selected
- *     Depends on whether a single row or multiple rows (interval) were selected
- * 2. Records the last selected row's row key value in the state
- * 3. Fires the `rowselection` event with the new selected rows in the details object
- *
- * @param {CustomEvent} event - `selectrow` event
- */
 export function handleSelectRow(event) {
     event.stopPropagation();
     const { state } = this;
@@ -111,16 +53,6 @@ export function handleSelectRow(event) {
         value: rowKeyValue,
     });
 }
-
-/**
- * Handles the de-selection of row(s)
- * 1. Marks the relevant rows as de-selected
- *     Depends on whether a single row or multiple rows (interval) was de-selected
- * 2. Records the last selected row's row key value in the state
- * 3. Fires the `rowselection` event with the new selected rows in the details object
- *
- * @param {CustomEvent} event - `deselectrow` event
- */
 export function handleDeselectRow(event) {
     event.stopPropagation();
     const { state } = this;
@@ -135,84 +67,46 @@ export function handleDeselectRow(event) {
         value: rowKeyValue,
     });
 }
-
-/**
- * Handles the `rowselection` event
- */
 export function handleRowSelectionChange() {
     updateBulkSelectionState(this.state);
 }
-
-/** ************************ ROW SELECTION **************************/
-
-/**
- * Marks all rows as selected.
- * Retrieve all rows from the state object. Iterate over these rows; for each:
- *     1. If the index is less than the specified max-row-selection value or
- *        if max-row-selection is not specified at all, set `isSelected` and
- *        `ariaSelected` to true and resolve `classnames` to reflect that the
- *        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 { 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];
         const selectedRowsCounter = enableDisabledRowsAttribute
             ? numRowsSelected
             : i;
-
         if (enableDisabledRowsAttribute && disabledRowsKeys[row.key]) {
             if (selectedRowsKeys[row.key]) {
                 newSelectedRowsKeys[row.key] = true;
             }
-        } else if (
-            (maxRowSelection === undefined ||
-                selectedRowsCounter < maxRowSelection) &&
+        }
+        else if ((maxRowSelection === undefined ||
+            selectedRowsCounter < maxRowSelection) &&
             (!isNewEditSelection(state, row.key) ||
-                newSelectionsCount < remainingEditSlots)
-        ) {
+                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 {
+        }
+        else {
             row.isDisabled = true;
             setRowSelectedAttributes(row, false);
         }
     }
     state.selectedRowsKeys = newSelectedRowsKeys;
 }
-
-/**
- * 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, deselectDisabledRows = true) {
     const { enableDisabledRowsAttribute } = features;
     const { disabledRowsKeys, rows, selectedRowsKeys } = state;
@@ -222,43 +116,22 @@ export function markAllRowsDeselected(state, deselectDisabledRows = true) {
         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
+        }
+        else {
             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
+            }
+            else if (!shouldEnable && selectedRowsKeys[row.key]) {
                 newSelectedRowsKeys[row.key] = true;
             }
         }
     }
     state.selectedRowsKeys = newSelectedRowsKeys;
 }
-
-/**
- * Marks rows as selected for all rows within the interval.
- * An interval is created when the user had initially selected a cell,
- * then does a Shift + click on a different row selection checkbox.
- * By doing so, all the rows (and checkboxes) between those two rows
- * will all be selected.
- *
- * Note that this function is also used not only for intervals but also
- * for single row selections. In that case, the startRowKey and
- * endRowKey will both have the same value.
- *
- * This does not handle the case when the header checkbox that selects
- * all rows of the table is clicked. That is handled by - `handleSelectAllRows`
- *
- * @param {Object} state - The datatable state
- * @param {String} startRowKey - row key value of the first row that was selected (start of the interval)
- * @param {String} endRowKey - row key value of the last row that was selected (end of the interval)
- */
 function markSelectedRowsInterval(state, startRowKey, endRowKey) {
     const { enableDisabledRowsAttribute } = features;
     const { disabledRowsKeys, rows } = state;
@@ -275,34 +148,14 @@ function markSelectedRowsInterval(state, startRowKey, endRowKey) {
         rowIndex += 1;
     }
 }
-
-/**
- * Marks rows as de-selected for all rows within the interval.
- * An interval for de-selection is created when the user ended selection or
- * de-selects a row and then does a Shift + click on a row that was previously selected.
- * By doing so, all the rows (and checkboxes) between the two rows will be de-selected
- *
- * Note that this function is also used not only for intervals but also
- * for single row de-selections. In that case, the startRowKey and
- * endRowKey will both have the same value.
- *
- * This does not handle the case when the header checkbox is clicked to de-select all rows
- * That is handledd by - `handleDeselectAllRows`
- *
- * @param {Object} state - The datatable state
- * @param {String} startRowKey - row key value of the first row that was selected (start of the interval)
- * @param {String} endRowKey - row key value of the last row that was selected (end of the interval)
- */
 function markDeselectedRowsInterval(state, startRowKey, endRowKey) {
     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];
         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) {
@@ -310,49 +163,26 @@ function markDeselectedRowsInterval(state, startRowKey, endRowKey) {
         }
     }
 }
-
-/**
- * Marks a row with the specified row key value as selected. This is done by:
- *     1. Sets `isSelected`, `ariaSelected` to true and resolves `classnames`
- *        to that which reflect that the row is selected, on the row object.
- *        These are used by the template to render the appropriate values.
- *     2. If max-row-selection > 1 or max-row-selection = 1 and single-row-selection-mode = 'checkbox' (checkbox/multi-selection),
- *         a. If with this selection, the max-row-selection value is reached,
- *            disable all the other un-selected rows
- *         b. Add the row key value of that row to the state
- *     3. If max-row-selection = 1 and single-row-selection-mode != 'checkbox'(radio button selector),
- *         a. If another row was previously selected before, de-select that row
- *         b. Add the row key value of that row to the state
- *
- * @param {Object} state - The datatable state
- * @param {String} rowKeyValue - row key value of row to mark selected
- */
 export function markRowSelected(state, rowKeyValue) {
     const row = getRowByKey(state, rowKeyValue);
     const prevSelectionLength = getCurrentSelectionLength(state);
     const total = state.maxRowSelection || state.rows.length;
-
     setRowSelectedAttributes(row, true);
-
     let { selectedRowsKeys } = state;
     const { singleRowSelectionMode } = state;
-    if (
-        total > 1 ||
+    if (total > 1 ||
         (total === 1 &&
-            singleRowSelectionMode === SINGLE_ROW_SELECTION_MODES.CHECKBOX)
-    ) {
+            singleRowSelectionMode === SINGLE_ROW_SELECTION_MODES.CHECKBOX)) {
         if (!selectedRowsKeys[row.key]) {
             selectedRowsKeys[row.key] = true;
             if (prevSelectionLength + 1 === total) {
                 markDeselectedRowDisabled(state);
             }
         }
-    } else {
+    }
+    else {
         if (prevSelectionLength === 1) {
-            const prevSelectedRow = getRowByKey(
-                state,
-                Object.keys(selectedRowsKeys)[0]
-            );
+            const prevSelectedRow = getRowByKey(state, Object.keys(selectedRowsKeys)[0]);
             setRowSelectedAttributes(prevSelectedRow, false);
             selectedRowsKeys = {};
             state.selectedRowsKeys = selectedRowsKeys;
@@ -360,54 +190,23 @@ export function markRowSelected(state, rowKeyValue) {
         selectedRowsKeys[row.key] = true;
     }
 }
-
-/**
- * Iterates over the row key values passed in and sets the relevant
- * values on the row object to reflect that it is selected.
- * Sets `isSelected`, `ariaSelected` and `classnames` on the row object
- * which are used by the template to render the appropriate values.
- *
- * @param {Object} state - The datatable state
- * @param {Array} keys - a list of row key values to be marked selected
- */
 function markRowsSelectedByKeys(state, keys) {
     for (let i = 0, { length } = keys; i < length; i += 1) {
         const row = getRowByKey(state, keys[i]);
         setRowSelectedAttributes(row, true);
     }
 }
-
-/**
- * Iterates over the row key values passed in and un-sets the relevant
- * values on the row object to reflect that it is not selected.
- * Sets `isSelected`, `ariaSelected` to false and resolves `classnames`
- * to one which reflects that the row is not selected on the row object.
- * These are used by the template to render the appropriate values.
- *
- * @param {Object} state - The datatable state
- * @param {Array} keys - a list of row key values to be marked selected
- */
 function markRowsDeselectedByKeys(state, keys) {
     for (let i = 0, { length } = keys; i < length; i += 1) {
         const row = getRowByKey(state, keys[i]);
         setRowSelectedAttributes(row, false);
     }
 }
-
-/**
- * Marks all deselected rows as disabled. This prevents the user
- * 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) {
     if (features.enableMaxEditLimit) {
         setDisabledRows(state);
-    } else {
-        // only disable unselected rows
+    }
+    else {
         const { rows, selectedRowsKeys } = state;
         for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
             const row = rows[i];
@@ -417,24 +216,12 @@ export function markDeselectedRowDisabled(state) {
         }
     }
 }
-
-/**
- * Marks all the deselected rows as enabled. This allows the user
- * to select more rows.
- * 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 { enableDisabledRowsAttribute, enableMaxEditLimit } = features;
-
     if (enableMaxEditLimit) {
         setDisabledRows(state);
-    } else {
-        // only enable unselected rows
+    }
+    else {
         const { rows, selectedRowsKeys, disabledRowsKeys } = state;
         for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
             const row = rows[i];
@@ -442,54 +229,30 @@ export function markDeselectedRowEnabled(state) {
                 if (!selectedRowsKeys[row.key] && !disabledRowsKeys[row.key]) {
                     row.isDisabled = false;
                 }
-            } else if (!selectedRowsKeys[row.key]) {
+            }
+            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}`
-        );
+    }
+    else {
+        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;
@@ -500,7 +263,6 @@ function updateDisabledRowsByKeys(state, newKeysArr) {
             }
         }
     }
-    // Enable rows unique to oldKeysObj
     const oldKeysArr = Object.keys(oldKeysObj);
     for (let i = 0, { length } = oldKeysArr; i < length; i += 1) {
         const rowKeyValue = oldKeysArr[i];
@@ -513,7 +275,6 @@ function updateDisabledRowsByKeys(state, newKeysArr) {
     }
     state.disabledRowsKeys = newKeysObj;
 }
-
 function markAllRowsEnabled(state) {
     const { rows } = state;
     for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
@@ -522,7 +283,6 @@ function markAllRowsEnabled(state) {
     }
     state.disabledRowsKeys = {};
 }
-
 function getDisabledRowCount(state) {
     if (!features.enableDisabledRowsAttribute) {
         return 0;
@@ -538,7 +298,6 @@ function getDisabledRowCount(state) {
     }
     return disabledCount;
 }
-
 function getDisabledAndSelectedRowCount(state) {
     if (!features.enableDisabledRowsAttribute) {
         return 0;
@@ -554,7 +313,6 @@ function getDisabledAndSelectedRowCount(state) {
     }
     return disabledAndSelectedCount;
 }
-
 function allRowsDisabled(state) {
     if (!features.enableDisabledRowsAttribute) {
         return false;
@@ -564,144 +322,68 @@ function allRowsDisabled(state) {
     const numDisabledRows = getDisabledRowCount(state);
     return numRows === numDisabledRows;
 }
-
 function isSelectedRadioDisabled(state) {
     if (!features.enableDisabledRowsAttribute) {
         return false;
     }
-    return (
-        !isInputTypeCheckbox(state) &&
-        getDisabledAndSelectedRowCount(state) === 1
-    );
+    return (!isInputTypeCheckbox(state) &&
+        getDisabledAndSelectedRowCount(state) === 1);
 }
-
-/** ************************ SELECTED ROW KEYS **************************/
-
-/**
- * This is called when the `selected-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.
- * If the number of valid keys exceeds the max-row-selection value, we use only the
- * number of keys from the valid list as that of the max-row-selection value.
- *
- * Compute the differences between the currently selected rows vs
- * the newly selected rows to find out which rows need to be additionally
- * selected and de-selected.
- * Based on the above computation, mark rows as selected or de-selected and
- * set the new `selectedRowsKeys` in the state object.
- *
- * If we select the max number of rows allowed and if max-row-selection > 1 (multi-select),
- * disable all the other rows.
- * If the previous selection had reached the max limit and the new selection
- * is less than the limit, re-enable the de-selected rows to allow for new selection.
- *
- * @param {Object} state - The datatable state
- * @param {Array} value - key-field values of rows to set as selected
- */
 export function setSelectedRowsKeys(state, value) {
     if (Array.isArray(value)) {
         const { maxRowSelection } = state;
         const previousSelectionLength = getCurrentSelectionLength(state);
         let selectedRows = filterValidKeys(state, value);
         if (selectedRows.length > maxRowSelection) {
-            // eslint-disable-next-line no-console
-            console.warn(
-                `The number of keys in selectedRows for lightning:datatable exceeds the limit defined by maxRowSelection.`
-            );
+            console.warn(`The number of keys in selectedRows for lightning:datatable exceeds the limit defined by maxRowSelection.`);
             selectedRows = selectedRows.slice(0, maxRowSelection);
         }
-
-        // check if max-edit-limit would be exceeded
-        if (
-            features.enableMaxEditLimit &&
-            !isUndefinedOrNull(state.maxEditLimit)
-        ) {
+        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)
-                );
+            if (currentEditedRowsCount + selectedRows.length >
+                maxEditableRows) {
+                console.warn(`The number of selected rows would exceed the limit defined by maxEditLimit (${maxEditableRows}).`);
+                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);
-
-        // Compute differences between currently selected rows and
-        // newly selected row keys. The diff will tell which new rows
-        // need to be selected and which already selected rows need to
-        // be deselected
         const selectionOperations = getSelectedDiff(state, selectedRows);
-        const deselectionOperations = getDeselectedDiff(
-            state,
-            selectedRowsKeys
-        );
+        const deselectionOperations = getDeselectedDiff(state, selectedRowsKeys);
         markRowsSelectedByKeys(state, selectionOperations);
         markRowsDeselectedByKeys(state, deselectionOperations);
         state.selectedRowsKeys = selectedRowsKeys;
-
         const { length: selectedRowsCount } = selectedRows;
-        // 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)) ||
-            isSelectedRadioDisabled(state)
-        ) {
+        if ((selectedRowsCount === maxRowSelection &&
+            isInputTypeCheckbox(state)) ||
+            isSelectedRadioDisabled(state)) {
             markDeselectedRowDisabled(state);
-        } else if (
-            selectedRowsCount < maxRowSelection &&
-            previousSelectionLength === maxRowSelection
-        ) {
-            // If the previous selection had reached the max limit and the new selection
-            // is less than the limit, re-enable the de-selected rows to allow for new selection.
+        }
+        else if (selectedRowsCount < maxRowSelection &&
+            previousSelectionLength === maxRowSelection) {
             markDeselectedRowEnabled(state);
         }
-    } else {
-        // eslint-disable-next-line no-console
-        console.error(
-            `The "selectedRows" passed into "lightning:datatable" must be an Array with the keys of the selected rows. We receive instead ${value}`
-        );
+    }
+    else {
+        console.error(`The "selectedRows" passed into "lightning:datatable" must be an Array with the keys of the selected rows. We receive instead ${value}`);
         markAllRowsDeselected(state);
     }
 }
-
 export function syncSelectedRowsKeys(state, selectedRows) {
     let changed = false;
     const { keyField, selectedRowsKeys, maxRowSelection } = state;
     const { length: selectedRowCount } = selectedRows;
     if (Object.keys(selectedRowsKeys).length !== selectedRowCount) {
         changed = true;
-        // Untracked state change.
-        state.selectedRowsKeys = updateSelectedRowsKeysFromSelectedRows(
-            selectedRows,
-            keyField
-        );
-    } else {
+        state.selectedRowsKeys = updateSelectedRowsKeysFromSelectedRows(selectedRows, keyField);
+    }
+    else {
         for (let i = 0; i < selectedRowCount; i += 1) {
             const row = selectedRows[i];
             if (!selectedRowsKeys[row[keyField]]) {
                 changed = true;
-                // Untracked state change.
-                state.selectedRowsKeys = updateSelectedRowsKeysFromSelectedRows(
-                    selectedRows,
-                    keyField
-                );
+                state.selectedRowsKeys = updateSelectedRowsKeysFromSelectedRows(selectedRows, keyField);
                 break;
             }
         }
@@ -709,15 +391,14 @@ export function syncSelectedRowsKeys(state, selectedRows) {
     if (changed) {
         const total = maxRowSelection || state.rows.length;
         if (isInputTypeCheckbox(state)) {
-            // Tracked state changes.
             if (selectedRowCount < total) {
                 markDeselectedRowEnabled(state);
-            } else {
+            }
+            else {
                 markDeselectedRowDisabled(state);
             }
         }
     }
-    // Tracked state change.
     updateBulkSelectionState(state);
     return {
         ifChanged(callback) {
@@ -727,7 +408,6 @@ export function syncSelectedRowsKeys(state, selectedRows) {
         },
     };
 }
-
 function updateSelectedRowsKeysFromSelectedRows(selectedRows, keyField) {
     const selectedRowsKeys = {};
     for (let i = 0, { length } = selectedRows; i < length; i += 1) {
@@ -736,7 +416,6 @@ function updateSelectedRowsKeysFromSelectedRows(selectedRows, keyField) {
     }
     return selectedRowsKeys;
 }
-
 function normalizeSelectedRowsKey(keys) {
     const selectedRowsKeys = {};
     for (let i = 0, { length } = keys; i < length; i += 1) {
@@ -744,7 +423,6 @@ function normalizeSelectedRowsKey(keys) {
     }
     return selectedRowsKeys;
 }
-
 function filterValidKeys(state, keys) {
     const filtered = [];
     const { rows } = state;
@@ -759,167 +437,79 @@ function filterValidKeys(state, keys) {
     }
     return filtered;
 }
-
-/** ************************ LAST SELECTED ROW KEYS **************************/
-
-/**
- * Returns the row key value of the row that was last selected
- * Returns undefined if the row key value is invalid
- *
- * @param {Object} state - The datatable state.
- * @returns {String | undefined } the row key or undefined.
- */
 function getLastRowSelection(state) {
     const { lastSelectedRowKey } = state;
-    const keyIsValid =
-        lastSelectedRowKey !== undefined &&
+    const keyIsValid = lastSelectedRowKey !== undefined &&
         getRowByKey(state, lastSelectedRowKey) !== undefined;
-
     return keyIsValid ? lastSelectedRowKey : undefined;
 }
-
-/** ************************ INPUT TYPES **************************/
-
-/**
- * Computes whether or not the input type rendered for row selection needs to change
- * The input type may need to change if:
- *     1. The max-row-selection value was previously 1 and is now either
- *        greater than 1 or is undefined OR
- *     2. The max-row-selection value was previously greater than 1 or undefined
- *        and is now 1 OR
- *     3. Previous max-row-selection value was 0 OR
- *     4. New max-row-selection value is 0
- *
- * @param {Number} previousMaxRowSelection
- * @param {Number} newMaxRowSelection
- * @returns {Boolean}
- */
-export function inputTypeNeedsToChange(
-    previousMaxRowSelection,
-    newMaxRowSelection
-) {
-    return (
-        previousMaxRowSelection === 0 ||
+export function inputTypeNeedsToChange(previousMaxRowSelection, newMaxRowSelection) {
+    return (previousMaxRowSelection === 0 ||
         newMaxRowSelection === 0 ||
         (previousMaxRowSelection === 1 &&
-            // is newMaxRowSelection multi-selection
             (newMaxRowSelection > 1 || newMaxRowSelection === undefined)) ||
         (newMaxRowSelection === 1 &&
-            // is previousMaxRowSelection multi-selection
             (previousMaxRowSelection > 1 ||
-                previousMaxRowSelection === undefined))
-    );
+                previousMaxRowSelection === undefined)));
 }
-
 export function updateRowSelectionInputType(state, datatableId) {
     const isCheckbox = isInputTypeCheckbox(state);
     const type = isCheckbox
         ? SINGLE_ROW_SELECTION_MODES.CHECKBOX
         : SINGLE_ROW_SELECTION_MODES.RADIO;
     const { rows } = state;
-
-    // Determine if inlining props need resetting
-    // And which column to reset if so
     let resetInliningProps = false;
     let checkboxColIndex;
     if (state.renderModeInline && !state.hideCheckboxColumn) {
         resetInliningProps = true;
         checkboxColIndex = state.showRowNumberColumn ? 1 : 0;
     }
-
     if (features.enableMaxEditLimit) {
         setDisabledRows(state);
-    } else {
+    }
+    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
-                );
+                setInliningProperties(state, row.cells[checkboxColIndex], isCheckbox, datatableId);
             }
         }
     }
 }
-
-/** ************************ MAX ROW SELECTION **************************/
-
-/**
- * Sets maxRowSelection to the provided value,
- * only keeping up to maxRowSelection values selected.
- *
- * Use input type checkbox if maxRowSelection > 1 or maxRowSelection = 1 and singleRowSelectionMode = 'checkbox'
- * and input type is radio if maxRowSelection = 1 and singleRowSelectionMode != 'checkbox'.
- * Invalid values are set to default and an error is logged
- *
- * @param {Object} state - The datatable state
- * @param {Number | String} - value to set for maxRowSelection
- */
 export function setMaxRowSelection(state, value, datatableId) {
     let previousSelectedRowsKeys;
     if (features.enableDisabledRowsAttribute) {
         previousSelectedRowsKeys = getRowsKeys(state.selectedRowsKeys);
-    } else {
+    }
+    else {
         previousSelectedRowsKeys = getSelectedRowsKeys(state);
     }
-    // Tracked state changes.
     markAllRowsDeselected(state);
     if (isNonNegativeInteger(value)) {
         const previousMaxRowSelection = state.maxRowSelection;
         const newMaxRowSelection = Number(value);
-        // Untracked state change.
         state.maxRowSelection = newMaxRowSelection;
-        // Reselect up to maxRowSelection rows.
-        const numberOfRows = Math.min(
-            previousSelectedRowsKeys.length,
-            newMaxRowSelection
-        );
+        const numberOfRows = Math.min(previousSelectedRowsKeys.length, newMaxRowSelection);
         for (let i = 0; i < numberOfRows; i += 1) {
-            // Tracked state changes.
             markRowSelected(state, previousSelectedRowsKeys[i]);
         }
-        if (
-            inputTypeNeedsToChange(previousMaxRowSelection, newMaxRowSelection)
-        ) {
-            // Tracked state changes.
+        if (inputTypeNeedsToChange(previousMaxRowSelection, newMaxRowSelection)) {
             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.
+    }
+    else {
         state.maxRowSelection = MAX_ROW_SELECTION_DEFAULT;
-        // suppress console error if no value is passed in
         if (value !== null && value !== undefined) {
-            // eslint-disable-next-line no-console
-            console.error(
-                `The maxRowSelection value passed into lightning:datatable should be a positive integer. We receive instead (${value}).`
-            );
+            console.error(`The maxRowSelection value passed into lightning:datatable should be a positive integer. We receive instead (${value}).`);
         }
     }
 }
-
-/** ************************ SINGLE ROW SELECTION MODE **************************/
-
-/**
- * Sets singleRowSelectionMode to the provided value.
- *
- * Use input type checkbox if maxRowSelection = 1 and singleRowSelectionMode = 'checkbox'
- * and input type is radio if maxRowSelection = 1 and singleRowSelectionMode != 'checkbox'.
- * Invalid values are set to default and an error is logged
- *
- * @param {Object} state - The datatable state
- * @param {Number | String} - value to set for maxRowSelection
- */
 export function setSingleRowSelectionMode(state, value, datatableId) {
     const resolvedValue = normalizeString(value, {
         fallbackValue: SINGLE_ROW_SELECTION_MODES.RADIO,
@@ -928,135 +518,73 @@ export function setSingleRowSelectionMode(state, value, datatableId) {
             SINGLE_ROW_SELECTION_MODES.RADIO,
         ],
     });
-
     if (resolvedValue !== state.singleRowSelectionMode) {
         state.singleRowSelectionMode = value;
         updateRowSelectionInputType(state, datatableId);
         updateBulkSelectionState(state);
     }
 }
-
-/** ************************ BULK SELECTION STATE **************************/
-
 export function updateBulkSelectionState(state) {
     const columns = state.columns || {};
     for (let colIndex = 0; colIndex < columns.length; colIndex += 1) {
         const col = columns[colIndex];
         if (col.type === SELECTABLE_HEADER_TYPE) {
-            const {
-                maxRowSelection,
-                rows: { length: rowCount },
-            } = state;
+            const { maxRowSelection, rows: { length: rowCount }, } = state;
             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 {
+                }
+                else {
                     updatedCol.enabledRowsSelected = false;
                 }
                 updatedCol.bulkSelection = selected === total ? 'all' : 'some';
-            } else {
+            }
+            else {
                 updatedCol.bulkSelection = 'none';
                 updatedCol.enabledRowsSelected = false;
             }
             updatedCol.isBulkSelectionDisabled =
                 maxRowSelection === 0 ||
-                rowCount === 0 ||
-                allRowsDisabled(state);
-            // Set the max selectable rows for the header label
+                    rowCount === 0 ||
+                    allRowsDisabled(state);
             updatedCol.maxSelectableRows = maxSelectableForLabel;
-            // Replace old column with shallow cloned and updated column.
             columns[colIndex] = updatedCol;
             return;
         }
     }
 }
-
-/** ************************ HELPER FUNCTIONS **************************/
-
-/**
- * Gets the interval of row indexes based on the start and end row key values
- * Retrieves the index of the row with startRowKey and the same with endRowKey
- * Returns an object that contains the start index which is the lower index value of the two
- * and the end index which is the higher value of the two.
- *
- * @param {Object} state - The datatable state
- * @param {String} startRowKey - The row key value of the first row that was selected (start of the interval)
- * @param {String} endRowKey - The row key value of the last row that was selected (end of the interval)
- * @returns {Object} - An object with start index and end index
- */
 function getRowIntervalIndexes(state, startRowKey, endRowKey) {
-    const start =
-        startRowKey === HEADER_ROW_KEY
-            ? 0
-            : getRowIndexByKey(state, startRowKey);
+    const start = startRowKey === HEADER_ROW_KEY
+        ? 0
+        : getRowIndexByKey(state, startRowKey);
     const end = getRowIndexByKey(state, endRowKey);
-
     return {
         start: Math.min(start, end),
         end: Math.max(start, end),
     };
 }
-
-/**
- * Sets aria-selected to 'true' on the cell identified by the rowKeyValue and colKeyValue.
- * This will reflect on the td or th or corresponding element in the role-based table.
- *
- * Note: This change is volatile, and will be reset (lost) in the next index regeneration.
- *
- * @param {Object} state - The datatable state
- * @param {String} rowKeyValue - The row key of the cell to mark selected
- * @param {String} colKeyValue - The column key of the cell to mark selected
- */
 export function setAriaSelectedOnCell(state, rowKeyValue, colKeyValue) {
     const cell = getCellByKeys(state, rowKeyValue, colKeyValue);
     if (cell) {
         cell.ariaSelected = 'true';
     }
 }
-
-/**
- * Sets aria-selected to 'false' on the cell identified by the rowKeyValue and colKeyValue.
- * This aria-selected attribute will be removed from the cell (if it was previously added))
- * on the td or th or the corresponding element in the role-based table.
- *
- * Note: This change is volatile, and will be reset (lost) in the next index regeneration.
- *
- * @param {Object} state - The datatable state
- * @param {String} rowKeyValue - The row key of the cell to select
- * @param {String} colKeyValue - The column key of the cell to select
- */
 export function unsetAriaSelectedOnCell(state, rowKeyValue, colKeyValue) {
     const cell = getCellByKeys(state, rowKeyValue, colKeyValue);
     if (cell) {
         cell.ariaSelected = false;
     }
 }
-
-/**
- * Sets `isSelected`, `ariaSelected` to true | false and resolves `classnames`
- * to one which reflects the selected value of the row on the row object.
- * These are used by the template to render the appropriate values.
- *
- * @param {Object} row - The row
- * @param {Boolean} selectedValue - Whether the row is selected
- */
 function setRowSelectedAttributes(row, selectedValue) {
     row.ariaSelected = selectedValue;
-    row.classnames = `slds-hint-parent${
-        selectedValue ? ' slds-is-selected' : ''
-    }`;
+    row.classnames = `slds-hint-parent${selectedValue ? ' slds-is-selected' : ''}`;
     row.isSelected = selectedValue;
 }
-
 function getSelectedDiff(state, selectedRows) {
     const filtered = [];
     const { selectedRowsKeys } = state;
@@ -1068,7 +596,6 @@ function getSelectedDiff(state, selectedRows) {
     }
     return filtered;
 }
-
 function getDeselectedDiff(state, value) {
     const filtered = [];
     const { selectedRowsKeys } = state;
@@ -1081,39 +608,28 @@ function getDeselectedDiff(state, value) {
     }
     return filtered;
 }
-
 export function updateRowDisabledStatesForEditLimit(state, types) {
-    if (
-        !features.enableMaxEditLimit ||
+    if (!features.enableMaxEditLimit ||
         isUndefinedOrNull(state.maxEditLimit) ||
-        !state.rows?.length
-    ) {
+        !state.rows?.length) {
         return;
     }
-
     setDisabledRows(state);
     updateCells(state, types);
 }
-
 export function getMaxSelectableRows(state) {
-    const {
-        maxRowSelection,
-        rows: { length: rowCount },
-    } = 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);
-}
+}