lightning-base-components 1.21.2-alpha → 1.21.3-alpha

package/src/lightning/datatable/rowSelection.js

@@ -79,15 +79,13 @@ export function handleDeselectAllRows(event) {
  */
 export function handleSelectRow(event) {
     event.stopPropagation();
+    const { state } = this;
     const { rowKeyValue, isMultiple } = event.detail;
-    let fromRowKey = rowKeyValue;
-
-    if (isMultiple) {
-        fromRowKey = getLastRowSelection(this.state) || rowKeyValue;
-    }
-
-    markSelectedRowsInterval(this.state, fromRowKey, rowKeyValue);
-    setLastRowSelection(this.state, rowKeyValue);
+    const fromRowKey = isMultiple
+        ? getLastRowSelection(state) || rowKeyValue
+        : rowKeyValue;
+    markSelectedRowsInterval(state, fromRowKey, rowKeyValue);
+    setLastRowSelection(state, rowKeyValue);
     this.fireSelectedRowsChange(this.getSelectedRows(), {
         action: ROWS_ACTION.ROW_SELECT,
         value: rowKeyValue,
@@ -105,15 +103,13 @@ export function handleSelectRow(event) {
  */
 export function handleDeselectRow(event) {
     event.stopPropagation();
+    const { state } = this;
     const { rowKeyValue, isMultiple } = event.detail;
-    let fromRowKey = rowKeyValue;
-
-    if (isMultiple) {
-        fromRowKey = getLastRowSelection(this.state) || rowKeyValue;
-    }
-
-    markDeselectedRowsInterval(this.state, fromRowKey, rowKeyValue);
-    setLastRowSelection(this.state, rowKeyValue);
+    const fromRowKey = isMultiple
+        ? getLastRowSelection(state) || rowKeyValue
+        : rowKeyValue;
+    markDeselectedRowsInterval(state, fromRowKey, rowKeyValue);
+    setLastRowSelection(state, rowKeyValue);
     this.fireSelectedRowsChange(this.getSelectedRows(), {
         action: ROWS_ACTION.ROW_DESELECT,
         value: rowKeyValue,
@@ -139,22 +135,23 @@ export function handleRowSelectionChange() {
  *     2. If max-row-selection has been reached, mark the remaining rows
  *        to reflect that they are not selected and disable them.
  *
- * @param {Object} state - datatable's state object
+ * @param {Object} state - The datatable state
  */
 export function markAllRowsSelected(state) {
     const rows = getRows(state);
     const maxRowSelection = getMaxRowSelection(state);
 
     resetSelectedRowsKeys(state);
-    rows.forEach((row, index) => {
-        if (index < maxRowSelection || maxRowSelection === undefined) {
+    for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
+        const row = rows[i];
+        if (maxRowSelection === undefined || i < maxRowSelection) {
             setRowSelectedAttributes(true, row);
             addKeyToSelectedRowKeys(state, row.key);
         } else {
             row.isDisabled = true;
             setRowSelectedAttributes(false, row);
         }
-    });
+    }
 }
 
 /**
@@ -163,17 +160,17 @@ export function markAllRowsSelected(state) {
  * 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 - datatable's state object
+ * @param {Object} state - The datatable state
  * @returns
  */
 export function markAllRowsDeselected(state) {
     const rows = getRows(state);
-
     resetSelectedRowsKeys(state);
-    rows.forEach((row) => {
+    for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
+        const row = rows[i];
         row.isDisabled = false;
         setRowSelectedAttributes(false, row);
-    });
+    }
 }
 
 /**
@@ -190,22 +187,20 @@ export function markAllRowsDeselected(state) {
  * 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 - datatable's state object
+ * @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 rows = getRows(state);
     const { start, end } = getRowIntervalIndexes(state, startRowKey, endRowKey);
-    const maxRowSelection = getMaxRowSelection(state) || getRowsTotal(state);
-    let i = start,
-        maxSelectionReached;
-
-    while (i <= end && !maxSelectionReached) {
-        markRowSelected(state, rows[i].key);
-        maxSelectionReached =
-            getCurrentSelectionLength(state) >= maxRowSelection;
-        i++;
+    const total = getMaxRowSelection(state) || getRowsTotal(state);
+    let rowIndex = start;
+    let maxSelectionReached;
+    while (rowIndex <= end && !maxSelectionReached) {
+        markRowSelected(state, rows[rowIndex].key);
+        maxSelectionReached = getCurrentSelectionLength(state) >= total;
+        rowIndex += 1;
     }
 }
 
@@ -222,7 +217,7 @@ function markSelectedRowsInterval(state, startRowKey, endRowKey) {
  * 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 - datatable's state object
+ * @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)
  */
@@ -230,8 +225,8 @@ function markDeselectedRowsInterval(state, startRowKey, endRowKey) {
     const rows = getRows(state);
     const { start, end } = getRowIntervalIndexes(state, startRowKey, endRowKey);
 
-    for (let i = start; i <= end; i++) {
-        markRowDeselected(state, rows[i].key);
+    for (let rowIndex = start; rowIndex <= end; rowIndex += 1) {
+        markRowDeselected(state, rows[rowIndex].key);
     }
 }
 
@@ -248,28 +243,28 @@ function markDeselectedRowsInterval(state, startRowKey, endRowKey) {
  *         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 - datatable's state object
+ * @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 maxRowSelection = getMaxRowSelection(state) || getRowsTotal(state);
-    const previousSelectionLength = getCurrentSelectionLength(state);
+    const prevSelectionLength = getCurrentSelectionLength(state);
+    const total = getMaxRowSelection(state) || getRowsTotal(state);
 
     setRowSelectedAttributes(true, row);
 
-    if (maxRowSelection > 1) {
+    if (total > 1) {
         addKeyToSelectedRowKeys(state, row.key);
-        if (previousSelectionLength + 1 === maxRowSelection) {
+        if (prevSelectionLength + 1 === total) {
             markDeselectedRowDisabled(state);
         }
     } else {
-        if (previousSelectionLength === 1) {
-            const previousSelectedRow = getRowByKey(
+        if (prevSelectionLength === 1) {
+            const prevSelectedRow = getRowByKey(
                 state,
                 Object.keys(state.selectedRowsKeys)[0]
             );
-            setRowSelectedAttributes(false, previousSelectedRow);
+            setRowSelectedAttributes(false, prevSelectedRow);
             resetSelectedRowsKeys(state);
         }
         addKeyToSelectedRowKeys(state, row.key);
@@ -307,14 +302,14 @@ export function markRowDeselected(state, rowKeyValue) {
  * Sets `isSelected`, `ariaSelected` and `classnames` on the row object
  * which are used by the template to render the appropriate values.
  *
- * @param {Object} state - datatable's state object
+ * @param {Object} state - The datatable state
  * @param {Array} keys - a list of row key values to be marked selected
  */
 function markRowsSelectedByKeys(state, keys) {
-    keys.forEach((rowKeyValue) => {
-        const row = getRowByKey(state, rowKeyValue);
+    for (let i = 0, { length } = keys; i < length; i += 1) {
+        const row = getRowByKey(state, keys[i]);
         setRowSelectedAttributes(true, row);
-    });
+    }
 }
 
 /**
@@ -324,14 +319,14 @@ function markRowsSelectedByKeys(state, keys) {
  * 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 - datatable's state object
+ * @param {Object} state - The datatable state
  * @param {Array} keys - a list of row key values to be marked selected
  */
 function markRowsDeselectedByKeys(state, keys) {
-    keys.forEach((rowKeyValue) => {
-        const row = getRowByKey(state, rowKeyValue);
+    for (let i = 0, { length } = keys; i < length; i += 1) {
+        const row = getRowByKey(state, keys[i]);
         setRowSelectedAttributes(false, row);
-    });
+    }
 }
 
 /**
@@ -344,11 +339,12 @@ function markRowsDeselectedByKeys(state, keys) {
  */
 export function markDeselectedRowDisabled(state) {
     const rows = getRows(state);
-    rows.forEach((row) => {
+    for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
+        const row = rows[i];
         if (!isSelectedRow(state, row.key)) {
             row.isDisabled = true;
         }
-    });
+    }
 }
 
 /**
@@ -358,15 +354,16 @@ export function markDeselectedRowDisabled(state) {
  * previously selected but a row was deselected, now allowing
  * any other row to be selected - for this, all rows should be enabled
  *
- * @param {Object} state - datatable's state object
+ * @param {Object} state - The datatable state
  */
 export function markDeselectedRowEnabled(state) {
     const rows = getRows(state);
-    rows.forEach((row) => {
+    for (let i = 0, { length: rowCount } = rows; i < rowCount; i += 1) {
+        const row = rows[i];
         if (!isSelectedRow(state, row.key)) {
             row.isDisabled = false;
         }
-    });
+    }
 }
 
 /************************** SELECTED ROW KEYS **************************/
@@ -409,8 +406,7 @@ export function setSelectedRowsKeys(state, value) {
 
         // Convert the selectedRows Array to an Object that state.selectedRowKeys expects
         // ['a', 'b'] -> { a : true, b : true}
-        const normalizedSelectedRowsKeys =
-            normalizeSelectedRowsKey(selectedRows);
+        const selectedRowsKeys = normalizeSelectedRowsKey(selectedRows);
 
         // Compute differences between currently selected rows and
         // newly selected row keys. The diff will tell which new rows
@@ -419,18 +415,19 @@ export function setSelectedRowsKeys(state, value) {
         const selectionOperations = getSelectedDiff(state, selectedRows);
         const deselectionOperations = getDeselectedDiff(
             state,
-            normalizedSelectedRowsKeys
+            selectedRowsKeys
         );
         markRowsSelectedByKeys(state, selectionOperations);
         markRowsDeselectedByKeys(state, deselectionOperations);
-        state.selectedRowsKeys = normalizedSelectedRowsKeys;
+        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 (selectedRows.length === maxRowSelection && maxRowSelection > 1) {
+        if (selectedRowsCount === maxRowSelection && maxRowSelection > 1) {
             markDeselectedRowDisabled(state);
         } else if (
-            selectedRows.length < maxRowSelection &&
+            selectedRowsCount < maxRowSelection &&
             previousSelectionLength === maxRowSelection
         ) {
             // If the previous selection had reached the max limit and the new selection
@@ -448,34 +445,45 @@ export function setSelectedRowsKeys(state, value) {
 
 export function syncSelectedRowsKeys(state, selectedRows) {
     let changed = false;
-    const { selectedRowsKeys, keyField } = state;
-    const maxRowSelection = getMaxRowSelection(state) || getRowsTotal(state);
+    const { keyField, selectedRowsKeys } = state;
+    const { length: selectedRowCount } = selectedRows;
     if (Object.keys(selectedRowsKeys).length !== selectedRows.length) {
         changed = true;
+        // Untracked state change.
         state.selectedRowsKeys = updateSelectedRowsKeysFromSelectedRows(
             selectedRows,
             keyField
         );
     } else {
-        changed = selectedRows.some((row) => !selectedRowsKeys[row[keyField]]);
-        if (changed) {
-            state.selectedRowsKeys = updateSelectedRowsKeysFromSelectedRows(
-                selectedRows,
-                keyField
-            );
+        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
+                );
+                break;
+            }
         }
     }
-    if (maxRowSelection > 1 && changed) {
-        if (selectedRows.length < maxRowSelection) {
-            markDeselectedRowEnabled(state);
-        } else {
-            markDeselectedRowDisabled(state);
+    if (changed) {
+        const total = getMaxRowSelection(state) || getRowsTotal(state);
+        if (total > 1) {
+            // Tracked state changes.
+            if (selectedRowCount < total) {
+                markDeselectedRowEnabled(state);
+            } else {
+                markDeselectedRowDisabled(state);
+            }
         }
     }
+    // Tracked state change.
     updateBulkSelectionState(state);
 
     return {
-        ifChanged: (callback) => {
+        ifChanged(callback) {
             if (changed && typeof callback === 'function') {
                 callback(selectedRows);
             }
@@ -484,10 +492,12 @@ export function syncSelectedRowsKeys(state, selectedRows) {
 }
 
 function updateSelectedRowsKeysFromSelectedRows(selectedRows, keyField) {
-    return selectedRows.reduce((selectedRowsKeys, row) => {
+    const selectedRowsKeys = {};
+    for (let i = 0, { length } = selectedRows; i < length; i += 1) {
+        const row = selectedRows[i];
         selectedRowsKeys[row[keyField]] = true;
-        return selectedRowsKeys;
-    }, {});
+    }
+    return selectedRowsKeys;
 }
 
 function addKeyToSelectedRowKeys(state, key) {
@@ -500,15 +510,23 @@ function removeKeyFromSelectedRowKeys(state, key) {
     state.selectedRowsKeys[key] = false;
 }
 
-function normalizeSelectedRowsKey(value) {
-    return value.reduce((map, key) => {
-        map[key] = true;
-        return map;
-    }, {});
+function normalizeSelectedRowsKey(keys) {
+    const selectedRowsKeys = {};
+    for (let i = 0, { length } = keys; i < length; i += 1) {
+        selectedRowsKeys[keys[i]] = true;
+    }
+    return selectedRowsKeys;
 }
 
 function filterValidKeys(state, keys) {
-    return keys.filter((key) => rowKeyExists(state, key));
+    const filtered = [];
+    for (let i = 0, { length } = keys; i < length; i += 1) {
+        const key = keys[i];
+        if (rowKeyExists(state, key)) {
+            filtered.push(key);
+        }
+    }
+    return filtered;
 }
 
 export function resetSelectedRowsKeys(state) {
@@ -521,11 +539,11 @@ export function resetSelectedRowsKeys(state) {
  * 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.
+ * @param {Object} state - The datatable state.
  * @returns {String | undefined } the row key or undefined.
  */
 function getLastRowSelection(state) {
-    const lastSelectedRowKey = state.lastSelectedRowKey;
+    const { lastSelectedRowKey } = state;
     const keyIsValid =
         lastSelectedRowKey !== undefined &&
         getRowIndexByKey(state, lastSelectedRowKey) !== undefined;
@@ -551,19 +569,18 @@ function setLastRowSelection(state, rowKeyValue) {
  *
  * @param {Number} previousMaxRowSelection
  * @param {Number} newMaxRowSelection
- * @returns
+ * @returns {Boolean}
  */
 export function inputTypeNeedsToChange(
     previousMaxRowSelection,
     newMaxRowSelection
 ) {
     return (
+        previousMaxRowSelection === 0 ||
+        newMaxRowSelection === 0 ||
         (previousMaxRowSelection === 1 &&
             isMultiSelection(newMaxRowSelection)) ||
-        (isMultiSelection(previousMaxRowSelection) &&
-            newMaxRowSelection === 1) ||
-        previousMaxRowSelection === 0 ||
-        newMaxRowSelection === 0
+        (newMaxRowSelection === 1 && isMultiSelection(previousMaxRowSelection))
     );
 }
 
@@ -571,10 +588,12 @@ export function updateRowSelectionInputType(state) {
     const type = getRowSelectionInputType(state);
     const rows = getRows(state);
 
-    rows.forEach((row) => {
+    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);
-    });
+    }
 }
 
 /************************** MAX ROW SELECTION **************************/
@@ -587,22 +606,25 @@ export function updateRowSelectionInputType(state) {
  * and input type is radio if maxRowSelection = 1.
  * Invalid values are set to default and an error is logged
  *
- * @param {Object} state - the datatable state.
+ * @param {Object} state - The datatable state
  * @param {Number | String} - value to set for maxRowSelection
  */
 export function setMaxRowSelection(state, value) {
     const previousSelectedRowsKeys = getSelectedRowsKeys(state);
+    // Tracked state changes.
     markAllRowsDeselected(state);
     if (isNonNegativeInteger(value)) {
         const previousMaxRowSelection = getMaxRowSelection(state);
+        // Untracked state change.
         state.maxRowSelection = Number(value);
         const newMaxRowSelection = getMaxRowSelection(state);
-        // reselect up to maxRowSelection rows
+        // Reselect up to maxRowSelection rows.
         const numberOfRows = Math.min(
             previousSelectedRowsKeys.length,
             newMaxRowSelection
         );
-        for (let i = 0; i < numberOfRows; i++) {
+        for (let i = 0; i < numberOfRows; i += 1) {
+            // Tracked state changes.
             markRowSelected(state, previousSelectedRowsKeys[i]);
         }
         if (
@@ -611,10 +633,12 @@ export function setMaxRowSelection(state, value) {
                 getMaxRowSelection(state)
             )
         ) {
+            // Tracked state changes.
             updateRowSelectionInputType(state);
             updateBulkSelectionState(state);
         }
     } else {
+        // Untracked state change.
         state.maxRowSelection = MAX_ROW_SELECTION_DEFAULT;
         // suppress console error if no value is passed in
         if (value !== null && value !== undefined) {
@@ -629,28 +653,24 @@ export function setMaxRowSelection(state, value) {
 /************************** BULK SELECTION STATE **************************/
 
 export function updateBulkSelectionState(state) {
-    const selectBoxesColumnIndex = getSelectBoxesColumnIndex(state);
-    if (selectBoxesColumnIndex >= 0) {
-        state.columns[selectBoxesColumnIndex] = Object.assign(
-            {},
-            state.columns[selectBoxesColumnIndex],
-            {
-                bulkSelection: getBulkSelectionState(state),
-                isBulkSelectionDisabled: isBulkSelectionDisabled(state),
-            }
-        );
+    const { columns } = state;
+    const colIndex = getSelectBoxesColumnIndex(state);
+    if (colIndex >= 0) {
+        const col = columns[colIndex];
+        const updatedCol = Object.assign({}, col);
+        updatedCol.bulkSelection = getBulkSelectionState(state);
+        updatedCol.isBulkSelectionDisabled = isBulkSelectionDisabled(state);
+        columns[colIndex] = updatedCol;
     }
 }
 
 function getBulkSelectionState(state) {
-    const selected = getCurrentSelectionLength(state);
     const total = getMaxRowSelection(state) || getRowsTotal(state);
-    if (selected === 0) {
-        return 'none';
-    } else if (selected === total) {
-        return 'all';
+    const selected = getCurrentSelectionLength(state);
+    if (selected) {
+        return selected === total ? 'all' : 'some';
     }
-    return 'some';
+    return 'none';
 }
 
 function isBulkSelectionDisabled(state) {
@@ -665,10 +685,10 @@ function isBulkSelectionDisabled(state) {
  * 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 - datatable's state object
- * @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)
- * @returns {Object} - object with start index and end index
+ * @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 =
@@ -687,9 +707,9 @@ function getRowIntervalIndexes(state, startRowKey, endRowKey) {
  *
  * Note: This change is volatile, and will be reset (lost) in the next index regeneration.
  *
- * @param {Object} state - the state of the datatable
- * @param {String} rowKeyValue - the row key of the cell to mark selected
- * @param {String} colKeyValue - the col key of the cell to mark selected
+ * @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 row = getRowByKey(state, rowKeyValue);
@@ -707,9 +727,9 @@ export function setAriaSelectedOnCell(state, rowKeyValue, colKeyValue) {
  *
  * Note: This change is volatile, and will be reset (lost) in the next index regeneration.
  *
- * @param {Object} state - the state of the datatable
- * @param {String} rowKeyValue - the row key of the cell to select
- * @param {String} colKeyValue - the col key of the cell to select
+ * @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 row = getRowByKey(state, rowKeyValue);
@@ -725,8 +745,8 @@ export function unsetAriaSelectedOnCell(state, rowKeyValue, colKeyValue) {
  * 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 {Boolean} selectedValue - is the row selected or not
- * @param {Object} row - the row on which to set the selected attributes
+ * @param {Boolean} selectedValue - Whether the row is selected
+ * @param {Object} row - The row
  */
 function setRowSelectedAttributes(selectedValue, row) {
     row.isSelected = selectedValue;
@@ -734,32 +754,40 @@ function setRowSelectedAttributes(selectedValue, row) {
     row.classnames = resolveRowClassNames(row);
 }
 
-function getSelectedDiff(state, value) {
-    const selectedRowsKeys = state.selectedRowsKeys;
-    return value.filter((key) => !selectedRowsKeys[key]);
+function getSelectedDiff(state, selectedRows) {
+    const filtered = [];
+    const { selectedRowsKeys } = state;
+    for (let i = 0, { length } = selectedRows; i < length; i += 1) {
+        const rowKeyValue = selectedRows[i];
+        if (!selectedRowsKeys[rowKeyValue]) {
+            filtered.push(rowKeyValue);
+        }
+    }
+    return filtered;
 }
 
 function getDeselectedDiff(state, value) {
-    const currentSelectedRowsKeys = state.selectedRowsKeys;
-    return Object.keys(currentSelectedRowsKeys).filter(
-        (key) => currentSelectedRowsKeys[key] && !value[key]
-    );
+    const filtered = [];
+    const { selectedRowsKeys } = state;
+    const keys = Object.keys(selectedRowsKeys);
+    for (let i = 0, { length } = keys; i < length; i += 1) {
+        const rowKeyValue = keys[i];
+        if (selectedRowsKeys[rowKeyValue] && !value[rowKeyValue]) {
+            filtered.push(rowKeyValue);
+        }
+    }
+    return filtered;
 }
 
 function getSelectBoxesColumnIndex(state) {
     const columns = getColumns(state) || [];
-    let selectBoxColumnIndex = -1;
-
-    columns.some((column, index) => {
-        if (column.type === SELECTABLE_ROW_CHECKBOX) {
-            selectBoxColumnIndex = index;
-            return true;
+    for (let colIndex = 0; colIndex < columns.length; colIndex += 1) {
+        const col = columns[colIndex];
+        if (col.type === SELECTABLE_ROW_CHECKBOX) {
+            return colIndex;
         }
-
-        return false;
-    });
-
-    return selectBoxColumnIndex;
+    }
+    return -1;
 }
 
 /**

package/src/lightning/datatable/rowSelectionShared.js

@@ -27,7 +27,7 @@ export function isSelectedRow(state, rowKeyValue) {
  *
  * NOTE: Do not disable selection when `max-row-selection` is 1 and a row has been selected.
  *
- * @param {Object} state Datatable state object
+ * @param {Object} state The datatable state
  * @param {String} rowKeyValue The row key value to lookup
  * @returns {Boolean} Whether the row should be disabled or not
  */
@@ -72,7 +72,7 @@ export function getMaxRowSelection(state) {
 /**
  * Determines the number of rows currently selected.
  *
- * @param {Object} state Datatable state object
+ * @param {Object} state The datatable state
  * @returns {Integer} The number of currently selected rows
  */
 export function getCurrentSelectionLength(state) {
@@ -82,11 +82,18 @@ export function getCurrentSelectionLength(state) {
 /**
  * Retrieves the row keys that are currently selected.
  *
- * @param {Object} state Datatable state object
+ * @param {Object} state The datatable state
  * @returns {Array} An array of the row keys that are currently selected
  */
 export function getSelectedRowsKeys(state) {
-    return Object.keys(state.selectedRowsKeys).filter(
-        (key) => state.selectedRowsKeys[key]
-    );
+    const filtered = [];
+    const { selectedRowsKeys } = state;
+    const keys = Object.keys(selectedRowsKeys);
+    for (let i = 0, { length } = keys; i < length; i += 1) {
+        const rowKeyValue = keys[i];
+        if (selectedRowsKeys[rowKeyValue]) {
+            filtered.push(rowKeyValue);
+        }
+    }
+    return filtered;
 }