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

package/src/lightning/datatable/virtualization.js

@@ -3,30 +3,13 @@
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-/**
- * increases table height to accommodate new data
- * used with infinite loading
- *
- * @param {Array} prevData - previous datatable data
- * @param {Array} newData - current datatable data
- */
 export function addTableHeight(state, prevData, newData) {
     const extraRowCount = newData.length - prevData.length;
     state.tableHeight += extraRowCount * state.rowHeight;
 }
-
-/**
- * resets state properties relevant to virtualization
- * rowHeights
- *
- * @param {Object} state - datatable state
- */
 export function resetRowHeights(state) {
     const { firstVisibleIndex } = state;
-    const firstRenderedIndex = Math.max(
-        firstVisibleIndex - state.bufferSize,
-        0
-    );
+    const firstRenderedIndex = Math.max(firstVisibleIndex - state.bufferSize, 0);
     const newOffsets = [0];
     const firstRenderedOffset = state.offsets[firstRenderedIndex];
     newOffsets[firstRenderedIndex] = firstRenderedOffset;
@@ -45,16 +28,6 @@ export function resetRowHeights(state) {
         state.tableHeight = firstRenderedOffset + remainingRowsHeight;
     }
 }
-
-/**
- * updates state properties relevant to virtualization
- * rowHeights
- *
- * @param {Node} template - the custom element root `this.template` from datatable.js
- * @param {Object} state - datatable state
- * @param {Array} renderedRows  - array of rows currently being rendered
- * @param {Object} refs - datatable refs
- */
 export function handleVariableRowHeights(template, state, renderedRows, refs) {
     const currentRange = {
         start: renderedRows[0].rowIndex,
@@ -62,242 +35,142 @@ export function handleVariableRowHeights(template, state, renderedRows, refs) {
     };
     let adjustFromIndex;
     let adjustmentValue = 0;
-    const offsetRangeIndex = findOffsetRangeIndex(
-        state.offsetRanges,
-        currentRange.start
-    );
-
-    const rowElements = template.querySelectorAll(
-        '[data-rowgroup-body] [role="row"]'
-    );
+    const offsetRangeIndex = findOffsetRangeIndex(state.offsetRanges, currentRange.start);
+    const rowElements = template.querySelectorAll('[data-rowgroup-body] [role="row"]');
     for (let i = 0; i < renderedRows.length; i++) {
         const row = renderedRows[i];
         if (!state.heightCache[row.key] && state.heightCache[row.key] !== 0) {
             const rowElement = rowElements[i];
             if (rowElement) {
-                // first rendered row needs height increased by 1 to account for missing border
                 let height = rowElement.getBoundingClientRect().height;
                 if (row.rowIndex && row.rowIndex === currentRange.start) {
                     height++;
                 }
                 state.heightCache[row.key] = height;
-
-                // calculate estimate of row offset
                 setOffset(state, row, offsetRangeIndex, height);
-
-                // update variables used to adjust later row offsets
                 adjustmentValue += height - state.rowHeight;
                 adjustFromIndex = row.rowIndex + 2;
             }
         }
     }
     state.tableHeight += adjustmentValue;
-    updateOffsetRanges(
-        state,
-        offsetRangeIndex,
-        currentRange,
-        adjustFromIndex,
-        adjustmentValue
-    );
+    updateOffsetRanges(state, offsetRangeIndex, currentRange, adjustFromIndex, adjustmentValue);
     updateVirtualizeStyles(template, state, renderedRows, refs);
 }
-
-/**
- * uses binary search with offsets and offsetRange
- * to determine what the first visible index should be
- * for a given scrollTop value
- */
 export function findFirstVisibleIndex(state, scrollTop) {
     const { offsetRanges, offsets, rowHeight } = state;
     let start = 0;
     let end = offsetRanges.length - 1;
-
     while (start <= end) {
         const mid = Math.floor((start + end) / 2);
         const prevRange = offsetRanges[mid];
         const nextRange = offsetRanges[mid + 1];
         const startOffset = offsets[prevRange.start];
         const endOffset = offsets[prevRange.end];
-
         const scrollTopAfterPrevStart = startOffset <= scrollTop;
-        const scrollTopInPrevRange =
-            scrollTopAfterPrevStart && scrollTop <= endOffset;
-        const scrollTopBeforeNextRange =
-            !nextRange || scrollTop < offsets[nextRange.start];
-        const scrollTopBetweenRanges =
-            scrollTopAfterPrevStart && scrollTopBeforeNextRange;
-
-        // check if scrollTop is in prevAdj offset values
-        // or between prevAdj and nextAdj offsetValues
+        const scrollTopInPrevRange = scrollTopAfterPrevStart && scrollTop <= endOffset;
+        const scrollTopBeforeNextRange = !nextRange || scrollTop < offsets[nextRange.start];
+        const scrollTopBetweenRanges = scrollTopAfterPrevStart && scrollTopBeforeNextRange;
         if (scrollTopInPrevRange) {
-            // find offset in prevRange to use for firstVisibleIndex
             return searchForOffset(state, prevRange, scrollTop);
-        } else if (scrollTopBetweenRanges) {
-            // use scrollTop and rowHeight to calculate firstVisibleIndex
+        }
+        else if (scrollTopBetweenRanges) {
             const diff = scrollTop - endOffset;
             const extraRows = Math.floor(diff / rowHeight);
             state.firstRowOffset = diff % rowHeight;
             return prevRange.end + extraRows;
         }
-        // update start or end for next round of binary search
         if (scrollTop < startOffset) {
             end = mid - 1;
-        } else {
+        }
+        else {
             start = mid + 1;
         }
     }
     return -1;
 }
-
-/**
- * determines the rowIndex for given scrollTop
- * within a provided offset range using binary search
- * also sets firstRowOffset to correct value
- *
- * @param {object} range - object with start and end index for binary search
- * @param {number} scrollTop - value to find offset rowIndex for
- * @returns {number} representing firstVisibleIndex for given scrollTop
- */
 function searchForOffset(state, range, scrollTop) {
     let { start, end } = range;
     const offsets = state.offsets;
-
     while (start <= end) {
         const mid = Math.floor((start + end) / 2);
         const currentOffsetUnderScrollTop = offsets[mid] <= scrollTop;
-        const nextOffsetUnderScrollTop =
-            offsets[mid + 1] && offsets[mid + 1] <= scrollTop;
-
+        const nextOffsetUnderScrollTop = offsets[mid + 1] && offsets[mid + 1] <= scrollTop;
         if (currentOffsetUnderScrollTop && !nextOffsetUnderScrollTop) {
-            // store how many pixels scrollTop is from top of row
             state.firstRowOffset = scrollTop - offsets[mid];
             return mid;
-        } else if (currentOffsetUnderScrollTop) {
+        }
+        else if (currentOffsetUnderScrollTop) {
             start = mid + 1;
-        } else {
+        }
+        else {
             end = mid - 1;
         }
     }
     return -1;
 }
-
-/**
- * uses a binary search to find the offsetRange index that
- * encompasses the provided row index, or the one immediately
- * before if no offsetRange encompasses the provided rowIndex
- */
 function findOffsetRangeIndex(offsetRanges, rowIndex) {
     let start = 0;
     let end = offsetRanges.length - 1;
     while (start <= end) {
         const mid = Math.floor((start + end) / 2);
-        const currentRangeStartsBeforeRowIndex =
-            offsetRanges[mid].start <= rowIndex;
-        const nextRangeStartsBeforeRowIndex =
-            offsetRanges[mid + 1] && offsetRanges[mid + 1].start <= rowIndex;
-
-        // check if rowIndex is between start of range at "mid"
-        // and start of range at "mid + 1" (or if there is no "mid + 1")
-        if (
-            currentRangeStartsBeforeRowIndex &&
-            !nextRangeStartsBeforeRowIndex
-        ) {
+        const currentRangeStartsBeforeRowIndex = offsetRanges[mid].start <= rowIndex;
+        const nextRangeStartsBeforeRowIndex = offsetRanges[mid + 1] && offsetRanges[mid + 1].start <= rowIndex;
+        if (currentRangeStartsBeforeRowIndex &&
+            !nextRangeStartsBeforeRowIndex) {
             return mid;
-        } else if (currentRangeStartsBeforeRowIndex) {
-            // look for earlier offsetRanges
+        }
+        else if (currentRangeStartsBeforeRowIndex) {
             start = mid + 1;
-        } else {
-            // look for later offsetRanges
+        }
+        else {
             end = mid - 1;
         }
     }
     return -1;
 }
-
-/**
- * sets the offset value for a given row and the next
- * based on the closest set offset value, the default
- * row height and the height of the current row
- *
- * @param {object} state - datatable state
- * @param {object} row - specific row object from state
- * @param {number} offsetRangeIndex - index of offset range to use for row
- * @param {number} height - height of row's node
- */
 function setOffset(state, row, offsetRangeIndex, height) {
     const currentRange = state.offsetRanges[offsetRangeIndex];
     let currentOffset = state.offsets[row.rowIndex];
-    // if no offset is set for current row, estimate it
-    // based on most recent offset and default rowHeight
     if (!currentOffset) {
         currentOffset = 0;
         if (currentRange) {
             const baseOffset = state.offsets[currentRange.end];
-            const estimatedRowOffsets =
-                (row.rowIndex - currentRange.end) * state.rowHeight;
+            const estimatedRowOffsets = (row.rowIndex - currentRange.end) * state.rowHeight;
             currentOffset = baseOffset + estimatedRowOffsets;
             state.offsets[row.rowIndex] = currentOffset;
         }
     }
-    // set next offset based on current offset and height
     state.offsets[row.rowIndex + 1] = currentOffset + height;
 }
-
-/**
- * merges or adds new offset range and
- * updates offsets and range values as needed
- *
- * @param {number} offsetRangeIndex
- * @param {*} state - datatable state
- * @param {object} currentRange - range for current rendered rows
- * @param {number} adjustFromIndex  - first index to increase by rangeValue
- * @param {number} rangeValue - amount to increase offsets after adjustFromIndex
- */
-function updateOffsetRanges(
-    state,
-    offsetRangeIndex,
-    currentRange,
-    adjustFromIndex,
-    adjustmentValue
-) {
+function updateOffsetRanges(state, offsetRangeIndex, currentRange, adjustFromIndex, adjustmentValue) {
     const { offsets, offsetRanges } = state;
     const prevRange = offsetRanges[offsetRangeIndex];
     const nextRange = offsetRanges[offsetRangeIndex + 1];
-    const overlapsWithPrevRange =
-        prevRange && checkOverlap(prevRange, currentRange);
-    const overlapsWithNextRange =
-        nextRange && checkOverlap(currentRange, nextRange);
-
-    // update remaining values in next range by
-    // adjustment value if we're overlapping it
+    const overlapsWithPrevRange = prevRange && checkOverlap(prevRange, currentRange);
+    const overlapsWithNextRange = nextRange && checkOverlap(currentRange, nextRange);
     if (overlapsWithNextRange && adjustmentValue) {
         for (let i = adjustFromIndex; i <= nextRange.end; i++) {
             offsets[i] += adjustmentValue;
         }
     }
-
-    // update state.offsetRanges
     if (overlapsWithPrevRange && overlapsWithNextRange) {
         nextRange.start = prevRange.start;
         nextRange.end = Math.max(currentRange.end, nextRange.end);
-        state.offsetRanges.splice(offsetRangeIndex, 1); // removes prevRange
-    } else if (overlapsWithPrevRange) {
+        state.offsetRanges.splice(offsetRangeIndex, 1);
+    }
+    else if (overlapsWithPrevRange) {
         prevRange.end = Math.max(prevRange.end, currentRange.end);
-    } else if (overlapsWithNextRange) {
+    }
+    else if (overlapsWithNextRange) {
         nextRange.start = currentRange.start;
         nextRange.end = Math.max(currentRange.end, nextRange.end);
-        // increase offsetRangeIndex; since it's values have already been updated
-        // we want to skip it when adjusting offsets in later ranges
         offsetRangeIndex += 1;
-    } else {
+    }
+    else {
         state.offsetRanges.splice(offsetRangeIndex + 1, 0, currentRange);
-        // need to increase offsetRangeIndex so we don't
-        // unnecessarily add adjustmentValue to currentRange
         offsetRangeIndex += 1;
     }
-
-    // loop through every offset range after the current one
-    // and increase the offset for each index by adjustmentValue
     if (offsetRangeIndex >= 0) {
         for (let i = offsetRangeIndex + 1; i < offsetRanges.length; i++) {
             const { start: rangeStart, end: rangeEnd } = offsetRanges[i];
@@ -307,38 +180,20 @@ function updateOffsetRanges(
         }
     }
 }
-
-/**
- * compares start/end of two ranges to see if the values overlap
- * used to determine if renderedRows are part of an existent offsetRange
- * or if a new offsetRange will need to be added
- */
 function checkOverlap(range1, range2) {
-    return (
-        (range1.start <= range2.start && range2.start <= range1.end) ||
-        (range1.start <= range2.end && range2.end <= range1.end)
-    );
+    return ((range1.start <= range2.start && range2.start <= range1.end) ||
+        (range1.start <= range2.end && range2.end <= range1.end));
 }
-
-/**
- * updates scrollTop and top values for rows when
- * using virtualization
- */
 function updateVirtualizeStyles(template, state, renderedRows, refs) {
-    // update scrollTop so firstVisibleIndex is correctly placed in viewport
-    const scrollerY =
-        refs?.scrollerY || template.querySelector('.slds-scrollable_y');
+    const scrollerY = refs?.scrollerY ||
+        template.querySelector('.slds-scrollable_y');
     scrollerY.scrollTop =
         state.offsets[state.firstVisibleIndex] + state.firstRowOffset;
-
-    // update top of rendered rows based on offsets
-    // if first rendered row isn't first row we need to
-    // add 1 to its offset to account for missing top border
     const addOffset = !!renderedRows[0].rowIndex;
     renderedRows.forEach((row, index) => {
         let top = state.offsets[row.rowIndex];
         if (addOffset && !index) {
-            top += 1; // reset first rendered row to offset in state
+            top += 1;
         }
         row.style = `position:absolute;top:${top}px;`;
     });

package/src/lightning/datatable/widthManagerShared.d.ts

@@ -0,0 +1,24 @@
+import { ColumnDefinition } from './types';
+export interface ColumnWidthMetaData {
+    minColumnWidth?: number;
+    maxColumnWidth?: number;
+    wrapTextMaxLines?: number;
+}
+export interface TotalWidthsData {
+    totalFixedWidth?: number;
+    totalFixedColumns?: number;
+    totalResizedWidth?: number;
+    totalResizedColumns?: number;
+    totalFlexibleColumns?: number;
+    minColumnWidth?: number;
+    maxColumnWidth?: number;
+    wrapTextMaxLines?: number;
+    columnWidths?: number[];
+    columnWidthsMode?: string;
+    resizeColumnDisabled?: boolean;
+    resizeStep?: number;
+    tableWidth?: number;
+}
+export declare function getTotalWidthsData(columnWidthMetaData: ColumnWidthMetaData, columns: ColumnDefinition[]): TotalWidthsData;
+export declare function getColumnWidth(column: ColumnDefinition): number | null;
+//# sourceMappingURL=widthManagerShared.d.ts.map

package/src/lightning/datatable/widthManagerShared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widthManagerShared.d.ts","sourceRoot":"","sources":["../../../../../modules/lightning/datatable/widthManagerShared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE3C,MAAM,WAAW,mBAAmB;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAUD,wBAAgB,kBAAkB,CAC9B,mBAAmB,EAAE,mBAAmB,EACxC,OAAO,EAAE,gBAAgB,EAAE,GAC5B,eAAe,CA4BjB;AAWD,wBAAgB,cAAc,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAStE"}

package/src/lightning/datatable/widthManagerShared.js

@@ -3,14 +3,6 @@
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-/**
- * Creates and returns a metadata object the contains information about the
- * number of fixed, flexible, and resized columns in the table
- *
- * @param {Object} columnWidthMetaData The initial column widths metadata
- * @param {Object} columns The state column definitions
- * @returns {Object} The computed metadata
- */
 export function getTotalWidthsData(columnWidthMetaData, columns) {
     const totalWidthsData = {
         totalFixedWidth: 0,
@@ -28,28 +20,21 @@ export function getTotalWidthsData(columnWidthMetaData, columns) {
         if (fixedWidth && isFinite(fixedWidth)) {
             totalWidthsData.totalFixedWidth += fixedWidth;
             totalWidthsData.totalFixedColumns += 1;
-        } else if (col.isResized) {
+        }
+        else if (col.isResized) {
             totalWidthsData.totalResizedWidth += col.columnWidth;
             totalWidthsData.totalResizedColumns += 1;
-        } else if (initialWidth && isFinite(initialWidth)) {
+        }
+        else if (initialWidth && isFinite(initialWidth)) {
             totalWidthsData.totalResizedWidth += initialWidth;
             totalWidthsData.totalResizedColumns += 1;
-        } else {
+        }
+        else {
             totalWidthsData.totalFlexibleColumns += 1;
         }
     }
     return totalWidthsData;
 }
-
-/**
- * Gets the width of a column. If the column has a fixed width,
- * it will always return that value. If the column does not have a fixed
- * width, it will return the resized value (if applicable), otherwise
- * the initial width.
- *
- * @param {Object} column The column object
- * @returns {Number} The fixed width, resized width, or initial width of the column (in that priority order)
- */
 export function getColumnWidth(column) {
     const { fixedWidth, initialWidth } = column;
     if (fixedWidth && isFinite(fixedWidth)) {

package/src/lightning/datatable/wrapText.d.ts

@@ -0,0 +1,9 @@
+import { DatatableState, ColumnDefinition, InternalAction } from './types';
+import LightningDatatable from './datatable';
+export declare function setWrapTextState(col: ColumnDefinition): void;
+export declare function setWrapTextMaxLines(state: DatatableState, value: string | number): void;
+export declare function getInternalActions(col: ColumnDefinition): InternalAction[];
+export declare function handleTriggeredAction(dt: LightningDatatable, action: {
+    name: string;
+}, colKeyValue: string): void;
+//# sourceMappingURL=wrapText.d.ts.map

package/src/lightning/datatable/wrapText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapText.d.ts","sourceRoot":"","sources":["../../../../../modules/lightning/datatable/wrapText.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC3E,OAAO,kBAAkB,MAAM,aAAa,CAAC;AAwB7C,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAM5D;AAWD,wBAAgB,mBAAmB,CAC/B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,MAAM,GAAG,MAAM,GACvB,IAAI,CAQN;AA+BD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,gBAAgB,GAAG,cAAc,EAAE,CAuB1E;AAWD,wBAAgB,qBAAqB,CACjC,EAAE,EAAE,kBAAkB,EACtB,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACxB,WAAW,EAAE,MAAM,GACpB,IAAI,CAeN"}

package/src/lightning/datatable/wrapText.js

@@ -9,7 +9,6 @@ import { normalizeBoolean } from 'lightning/utilsPrivate';
 import { getStateColumnIndex } from './columns';
 import { updateCell } from './rows';
 import { normalizeNumberAttribute } from './utils';
-
 const NON_WRAPPABLE_TYPES = new Set([
     'action',
     'boolean',
@@ -18,77 +17,30 @@ const NON_WRAPPABLE_TYPES = new Set([
     'date-local',
     'rowNumber',
 ]);
-
 const i18n = {
     clipText: labelClipText,
     wrapText: labelWrapText,
 };
-
-/** ************************ WRAP TEXT STATE **************************/
-
-/**
- * Normalizes the value for the column's wrapText property
- * Based on cell type and current wrapText value.
- *
- * @param {Object} col The datatable column definition
- */
 export function setWrapTextState(col) {
     if (!NON_WRAPPABLE_TYPES.has(col.type)) {
         col.wrapText = normalizeBoolean(col.wrapText);
-    } else {
+    }
+    else {
         col.wrapText = false;
     }
 }
-
-/** ************************ WRAP TEXT MAX LINES **************************/
-
-/**
- * Normalizes and sets wrapTextMaxLines in datatable state object.
- * The normalized value should be a positive integer or it'll fall back to undefined.
- *
- * @param {Object} state The datatable state
- * @param {Integer} value The maximum lines allowed
- */
 export function setWrapTextMaxLines(state, value) {
-    state.wrapTextMaxLines = normalizeNumberAttribute(
-        'wrapTextMaxLines',
-        value,
-        'positive',
-        undefined
-    );
+    state.wrapTextMaxLines = normalizeNumberAttribute('wrapTextMaxLines', value, 'positive', undefined);
     state.shouldResetHeights = true;
 }
-
-/**
- * Sets the `wrapText` and `wrapTextMaxLines` values in the cell object for all cells in a column.
- * These values are used by primitiveCellFactory to set the required classes on the cell for wrapping
- *
- * @param {Object} state Datatable's state object
- * @param {Number} colIndex The column index to update
- * @param {String} colKeyValue The column key value to look up wrap text configuration
- */
 function updateWrapTextAndMaxLinesValuesInCells(state, colIndex) {
     const { data, rows } = state;
     for (let i = 0; i < rows.length; i += 1) {
         updateCell(state, i, colIndex, data[i]);
     }
 }
-
-/** ************************ HEADER ACTIONS **************************/
-
-/**
- * Returns an object representing the two internal header actions that datatable
- * provides - Wrap Text and Clip Text.
- * Each header action contains a label, title, action name and its selected value (checked)
- *
- * @param {Object} state The datatable state
- * @param {Object} col The datatable column definition
- * @returns {Array} An array of wrap text actions
- */
 export function getInternalActions(col) {
-    // Must be done first to ensure isTextWrapped correctly resolves.
     setWrapTextState(col);
-    // If not hidden and isWrapable, sets the internal actions.
     if (col.hideDefaultActions || NON_WRAPPABLE_TYPES.has(col.type)) {
         return [];
     }
@@ -109,16 +61,6 @@ export function getInternalActions(col) {
         },
     ];
 }
-
-/**
- * If the action is an internal action and if the wrapText value for a column
- * needs to be changed in the state, change it to the new value and update
- * the check mark to represent the currently selected action
- *
- * @param {Object} dt The datatable
- * @param {String} action Action that was selected/triggered
- * @param {String} colKeyValue Column key value
- */
 export function handleTriggeredAction(dt, action, colKeyValue) {
     const { name } = action;
     const isWrapText = name === 'wrapText';
@@ -126,7 +68,6 @@ export function handleTriggeredAction(dt, action, colKeyValue) {
         const { state } = dt;
         const colIndex = getStateColumnIndex(state, colKeyValue);
         const col = state.columns[colIndex];
-        // If state should be changed
         if (col.wrapText !== isWrapText) {
             state.shouldResetHeights = true;
             col.wrapText = isWrapText;
@@ -135,14 +76,6 @@ export function handleTriggeredAction(dt, action, colKeyValue) {
     }
     dt._recalculateHeaderHeight = true;
 }
-
-/**
- * Update the 'checked' value of the each action to show which action is selected
- * and which action is not selected.
- *
- * @param {Object} state The datatable state.
- * @param {String} colKeyValue The column key.
- */
 function updateSelectedOptionInHeaderActions(state, colKeyValue) {
     const colIndex = getStateColumnIndex(state, colKeyValue);
     if (colIndex === -1) {
@@ -151,19 +84,16 @@ function updateSelectedOptionInHeaderActions(state, colKeyValue) {
     const { columns } = state;
     const col = columns[colIndex];
     const { internalActions } = col.actions;
-
     for (let i = 0; i < internalActions.length; i += 1) {
         const action = internalActions[i];
         const { name } = action;
         if (name === 'wrapText') {
             action.checked = col.wrapText;
-        } else if (name === 'clipText') {
+        }
+        else if (name === 'clipText') {
             action.checked = !col.wrapText;
         }
     }
-
     updateWrapTextAndMaxLinesValuesInCells(state, colIndex);
-
-    // Force a refresh on this column, because the wrapText checked value changed.
     col.actions = Object.assign({}, col.actions);
 }

package/src/lightning/datatableKeyboardMixins/baseNavigation.d.ts

@@ -0,0 +1,33 @@
+export function baseNavigation(superclass: any): {
+    new (): {
+        [x: string]: any;
+        _keyboardMode: string;
+        keyboardMode: string;
+        focus(): void;
+        connectedCallback(): void;
+        [updateActionables](): void;
+        [handleArrowKeyDown](event: any): void;
+        [handleArrowLeft](event: any): void;
+        [handleArrowRight](event: any): void;
+        [handleTabKey](event: any): void;
+        [getActiveElementIndex](): number;
+        [moveToPreviousOf](index: any): void;
+        [moveToNextOf](index: any): void;
+        [lastElementFocused]: HTMLElement;
+        [privateActionables]: HTMLElement[];
+    };
+    [x: string]: any;
+    delegatesFocus: boolean;
+};
+declare const updateActionables: unique symbol;
+declare const handleArrowKeyDown: unique symbol;
+declare const handleArrowLeft: unique symbol;
+declare const handleArrowRight: unique symbol;
+declare const handleTabKey: unique symbol;
+declare const getActiveElementIndex: unique symbol;
+declare const moveToPreviousOf: unique symbol;
+declare const moveToNextOf: unique symbol;
+declare const lastElementFocused: unique symbol;
+declare const privateActionables: unique symbol;
+export {};
+//# sourceMappingURL=baseNavigation.d.ts.map

package/src/lightning/datatableKeyboardMixins/baseNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseNavigation.d.ts","sourceRoot":"","sources":["../../../../../modules/interop/datatableKeyboardMixins/baseNavigation.js"],"names":[],"mappings":"AA4BO;;;;;;;;;;;;;;;;;;;;EAiJF;AAlKL,+CAAsD;AACtD,gDAAwD;AARxD,6CAAkD;AAClD,8CAAoD;AACpD,0CAA4C;AAC5C,mDAA8D;AAC9D,8CAAoD;AACpD,0CAA4C;AAI5C,gDAAwD;AAHxD,gDAAwD"}