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

package/src/lightning/datatable/autoWidthStrategy.js

@@ -1,8 +1,5 @@
-import {
-    getTotalWidthsMetadata,
-    getColumnWidthFromDef,
-} from './widthManagerShared';
 import { clamp } from './utils';
+import { getColumnWidth, getTotalWidthsData } from './widthManagerShared';
 
 const MIN_MAX_THRESHOLD = 0.5;
 const TRUNCATION_ALLOWANCE = 20;
@@ -25,7 +22,11 @@ function hasColumn(columns, colIndex) {
  * @returns {Number} The total width of all columns
  */
 function getTotalColumnWidth(columnWidths) {
-    return columnWidths.reduce((acc, value) => acc + value, 0);
+    let total = 0;
+    for (let i = 0, { length } = columnWidths; i < length; i += 1) {
+        total += columnWidths[i];
+    }
+    return total;
 }
 
 /**
@@ -56,12 +57,12 @@ function canAddWidth(currentWidth, widthToAdd, maxColumnWidth) {
  * Determines the expected table width
  *
  * @param {Number} availableWidth The available width for the entire table
- * @param {Object} widthsMetadata The widths metadata object
+ * @param {Object} widthsData The widths data
  * @returns {Number} The expected width of the table
  */
-function getExpectedTableWidth(availableWidth, widthsMetadata) {
-    const minExpectedTableWidth = getMinExpectedTableWidth(widthsMetadata);
-    return widthsMetadata.totalFlexibleColumns === 0
+function getExpectedTableWidth(availableWidth, widthsData) {
+    const minExpectedTableWidth = getMinExpectedTableWidth(widthsData);
+    return widthsData.totalFlexibleColumns === 0
         ? minExpectedTableWidth
         : Math.max(minExpectedTableWidth, availableWidth);
 }
@@ -69,18 +70,17 @@ function getExpectedTableWidth(availableWidth, widthsMetadata) {
 /**
  * Determines the minimum expected table width
  *
- * @param {Object} widthsMetadata The widths metadata object
+ * @param {Object} widthsData The widths data
  * @returns {Number} The minimum expected table width
  */
-function getMinExpectedTableWidth(widthsMetadata) {
-    const {
-        totalFixedWidth,
-        totalResizedWidth,
-        totalFlexibleColumns,
-        minColumnWidth,
-    } = widthsMetadata;
-    const minTotalFlexibleWidth = totalFlexibleColumns * minColumnWidth;
-    return minTotalFlexibleWidth + totalFixedWidth + totalResizedWidth;
+function getMinExpectedTableWidth(widthsData) {
+    const minTotalFlexibleWidth =
+        widthsData.totalFlexibleColumns * widthsData.minColumnWidth;
+    return (
+        minTotalFlexibleWidth +
+        widthsData.totalFixedWidth +
+        widthsData.totalResizedWidth
+    );
 }
 
 /**
@@ -91,21 +91,21 @@ export class AutoWidthStrategy {
 
     // Instance array to hold column width ratios either calculated from visual distribution of column labels
     // or from distribution of data amongst the columns. These ratios are reused except when datatable reacts
-    // to changes in data or columns and other variablesat which point they are recalculated.
-    _columnWidthRatios = [];
+    // to changes in data or columns and other variables at which point they are recalculated.
+    columnWidthRatios = [];
 
     // Object used to store `minColumnWidth`, `maxColumnWidth`, along with other metadata like `totalFixedColumns`
-    // Refer: widthManagerShared.js getTotalWidthsMetadata
-    _columnWidthMetaData = {};
+    // Refer: widthManagerShared.js getTotalWidthsData
+    columnWidthData = {};
 
     // Object which holds columns with min width (+ threshold) and columns with max width (-threshold)
     // It is used in redistribution of extra space that is left or taken up while calculating auto widths
-    _columnWidthsDistribution = {};
+    columnWidthsDistribution = {};
 
     /************************** LIFECYCLE HOOKS **************************/
 
     constructor(minColumnWidth, maxColumnWidth, wrapTextMaxLines = 3) {
-        this._columnWidthMetaData = {
+        this.columnWidthData = {
             minColumnWidth,
             maxColumnWidth,
             wrapTextMaxLines,
@@ -122,7 +122,7 @@ export class AutoWidthStrategy {
      * @param {Number} value The minimum column width in pixels
      */
     set minColumnWidth(value) {
-        this._columnWidthMetaData.minColumnWidth = value;
+        this.columnWidthData.minColumnWidth = value;
     }
 
     /**
@@ -131,7 +131,7 @@ export class AutoWidthStrategy {
      * @param {Number} value The maximum column width in pixels
      */
     set maxColumnWidth(value) {
-        this._columnWidthMetaData.maxColumnWidth = value;
+        this.columnWidthData.maxColumnWidth = value;
     }
 
     /**
@@ -140,33 +140,9 @@ export class AutoWidthStrategy {
      * @param {Number} value The maximum number of lines
      */
     set wrapTextMaxLines(value) {
-        this._columnWidthMetaData.wrapTextMaxLines = value;
-    }
-
-    /************************** PRIVATE GETTERS **************************/
-
-    /**
-     * Gets the column width ratios
-     * See `_columnWidthRatios` in Private Variables for more information.
-     *
-     * @returns {Array} An array of column width ratios
-     */
-    get columnWidthRatios() {
-        return this._columnWidthRatios;
+        this.columnWidthData.wrapTextMaxLines = value;
     }
 
-    /**
-     * Gets the column width distribution.
-     * See `_columnWidthsDistribution` in Private Variables for more information.
-     *
-     * @returns {Object} An object of column width distributions
-     */
-    get columnWidthsDistribution() {
-        return this._columnWidthsDistribution;
-    }
-
-    /************************* HELPER FUNCTIONS **************************/
-
     /**
      * Get adjusted column widths from existing ratios which are based on data cells room taken
      * or based on column labels space in headers. If `recomputeAutoWidthRatios` is true or ratios
@@ -174,55 +150,48 @@ export class AutoWidthStrategy {
      * ratio. Any remaining space or extra space taken is then redistributed in second pass.
      *
      * @param {Object} datatableInterface Interface to datatable with callbacks giving width information
-     * @param {Object} columnDefs Column definitions array with defined widths and other attributes
+     * @param {Object} columns Column definitions array with defined widths and other attributes
      * @param {Boolean} recomputeAutoWidthRatios Whether ratios should be recalculated
      * @returns {Object} columnWidths: [], expectedTableWidth: (number)
      */
     getAdjustedColumnWidths(
         datatableInterface,
-        columnDefs,
+        columns,
         recomputeAutoWidthRatios
     ) {
-        const widthsMetadata = getTotalWidthsMetadata(
-            this._columnWidthMetaData,
-            columnDefs
-        );
-
+        const widthsData = getTotalWidthsData(this.columnWidthData, columns);
         const availableWidth = datatableInterface.getAvailableWidthFromDom();
-
-        let expectedTableWidth = getExpectedTableWidth(
+        const expectedTableWidth = getExpectedTableWidth(
             availableWidth,
-            widthsMetadata,
-            columnDefs
+            widthsData,
+            columns
         );
 
-        this._resetColumnWidthsDistribution();
+        this.resetColumnWidthsDistribution();
 
         if (recomputeAutoWidthRatios || this.columnWidthRatios.length === 0) {
-            this._calculateColumnWidthRatios(
+            this.calculateColumnWidthRatios(
                 datatableInterface,
-                columnDefs,
-                widthsMetadata
+                columns,
+                widthsData
             );
         }
 
-        let columnWidths = [];
         // If the lengths don't match, return
         if (
             recomputeAutoWidthRatios &&
-            this.columnWidthRatios.length !== columnDefs.length
+            this.columnWidthRatios.length !== columns.length
         ) {
-            return { expectedTableWidth, columnWidths };
+            return { expectedTableWidth, columnWidths: [] };
         }
 
         // First pass - Distribute widths as per ratios or defined widths if there are any
-        columnWidths = this._distributeWidthFromRatios(
+        const columnWidths = this.distributeWidthFromRatios(
             expectedTableWidth,
-            columnDefs,
-            widthsMetadata
+            columns,
+            widthsData
         );
-
-        let columnWidthsSum = getTotalColumnWidth(columnWidths);
+        const columnWidthsSum = getTotalColumnWidth(columnWidths);
 
         // Second pass - There could be excess width remaining due to clamping to `maxWidth`
         // or we might have used more space due to clamping to `minWidth `in certain cases.
@@ -231,95 +200,94 @@ export class AutoWidthStrategy {
         // We need to redistribute this space using below methods.
         if (expectedTableWidth > columnWidthsSum) {
             // We have more space, let's redistribute space
-            this._redistributeExtraWidth(
+            this.redistributeExtraWidth(
                 expectedTableWidth,
                 columnWidths,
-                columnDefs
+                columns
             );
         } else if (expectedTableWidth < columnWidthsSum) {
             // We have to take away used space
-            this._redistributeDeficitWidth(
+            this.redistributeDeficitWidth(
                 expectedTableWidth,
                 columnWidths,
-                columnDefs
+                columns
             );
         }
         return { columnWidths, expectedTableWidth };
     }
 
     /**
-     * @private
      * Calculates the ratios for each cell based on available space for a given row.
      *
      * @param {Array} cellWidths An array of the cell widths
      * @param {Number} totalWidth The total available width
      * @returns {Array} An array of cell width ratios
      */
-    _getRatios(cellWidths, totalWidth) {
-        return cellWidths.map((cellWidth) => {
-            return (100 * cellWidth) / totalWidth;
-        });
+    getRatios(cellWidths, totalWidth) {
+        const { length } = cellWidths;
+        const ratios = Array(length);
+        for (let i = 0; i < length; i += 1) {
+            ratios[i] = (100 * cellWidths[i]) / totalWidth;
+        }
+        return ratios;
     }
 
     /**
-     * @private
      * Calculates and sets the column width ratios object.
      *
      * @param {Object} datatableInterface The datatable
-     * @param {Array} columnDefs The column definitions
-     * @param {Object} widthsMetadata The widths metadata object
+     * @param {Array} columns The column definitions
+     * @param {Object} widthsData The widths data
      */
-    _calculateColumnWidthRatios(
-        datatableInterface,
-        columnDefs,
-        widthsMetadata
-    ) {
+    calculateColumnWidthRatios(datatableInterface, columns, widthsData) {
         // Take into account columns with text wrapping
-        const dataCellWidths = datatableInterface
-            .getDataCellWidths()
-            .map((width, index) => {
-                const columnDefinition = columnDefs[index];
-                if (columnDefinition) {
-                    if (columnDefinition.wrapText) {
-                        return width / widthsMetadata.wrapTextMaxLines;
-                    }
-                    if (columnDefinition.fixedWidth) {
-                        return columnDefinition.fixedWidth;
+        const { wrapTextMaxLines } = widthsData;
+        const dataCellWidths = datatableInterface.getDataCellWidths();
+        for (
+            let colIndex = 0, { length } = dataCellWidths;
+            colIndex < length;
+            colIndex += 1
+        ) {
+            const col = columns[colIndex];
+            if (col) {
+                if (col.wrapText) {
+                    const width = dataCellWidths[colIndex];
+                    dataCellWidths[colIndex] = width / wrapTextMaxLines;
+                } else {
+                    const { fixedWidth } = col;
+                    if (fixedWidth) {
+                        dataCellWidths[colIndex] = fixedWidth;
                     }
                 }
-                return width;
-            });
-        const headerCellWidths = datatableInterface.getHeaderCellWidths();
-        const tableScrollWidth = datatableInterface.getTableElementWidth();
-
-        this._setColumnWidthRatios(
-            tableScrollWidth,
+            }
+        }
+        this.setColumnWidthRatios(
+            datatableInterface.getTableElementWidth(),
             dataCellWidths,
-            headerCellWidths,
-            widthsMetadata
+            datatableInterface.getHeaderCellWidths(),
+            widthsData
         );
     }
 
     /**
-     * @private
      * Calculates and creates the column width ratios array.
      *
      * @param {Number} tableScrollWidth The width of the table that is hidden behind a hotizontal scroll
      * @param {Array} dataCellWidths An array of the widths of the data cells
      * @param {Array} headerCellWidths An array of the widths of the header cells
-     * @param {Object} widthsMetadata The raw widths metadata object
+     * @param {Object} widthsData The unwrapped widths data
      */
-    _setColumnWidthRatios(
+    setColumnWidthRatios(
         tableScrollWidth,
         dataCellWidths,
         headerCellWidths,
-        widthsMetadata
+        widthsData
     ) {
         // Reset ratios
-        this._columnWidthRatios = [];
+        this.columnWidthRatios = [];
 
         if (tableScrollWidth > 0) {
-            const { totalFixedWidth, totalResizedWidth } = widthsMetadata;
+            const { totalFixedWidth, totalResizedWidth } = widthsData;
 
             if (dataCellWidths.length === 0) {
                 if (headerCellWidths.length > 0) {
@@ -334,7 +302,7 @@ export class AutoWidthStrategy {
                     const totalFlexibleWidth =
                         totalHeaderWidth - totalFixedWidth - totalResizedWidth;
                     // Calculate ratio from header cells
-                    this._columnWidthRatios = this._getRatios(
+                    this.columnWidthRatios = this.getRatios(
                         headerCellWidths,
                         totalFlexibleWidth
                     );
@@ -350,7 +318,7 @@ export class AutoWidthStrategy {
                     totalResizedWidth;
 
                 // Calculate ratio from data cells
-                this._columnWidthRatios = this._getRatios(
+                this.columnWidthRatios = this.getRatios(
                     dataCellWidths,
                     totalFlexibleWidth
                 );
@@ -359,114 +327,103 @@ export class AutoWidthStrategy {
     }
 
     /**
-     * @private
      * Resets the column width distribution.
      */
-    _resetColumnWidthsDistribution() {
+    resetColumnWidthsDistribution() {
         this.columnWidthsDistribution.colsWithMinWidth = [];
         this.columnWidthsDistribution.colsWithMaxWidth = [];
     }
 
     /**
-     * @private
      * Allocates width to a column as per defined width or as per ratio.
      *
      * @param {Number} availableWidth Available width for the table
-     * @param {Object} columnDefs Column definitions in state
-     * @param {Object} widthsMetadata Metadata regarding widths includes `max`, `min`, `flexiblewidth`, `fixedwidth`
+     * @param {Object} columns Column definitions in state
+     * @param {Object} widthsData Metadata regarding widths includes `max`, `min`, `flexiblewidth`, `fixedwidth`
      */
-    _distributeWidthFromRatios(availableWidth, columnDefs, widthsMetadata) {
+    distributeWidthFromRatios(availableWidth, columns, widthsData) {
         const columnWidths = [];
-        columnDefs.forEach((column, colIndex) => {
+        for (let colIndex = 0; colIndex < columns.length; colIndex += 1) {
+            const col = columns[colIndex];
             const width =
-                getColumnWidthFromDef(column) ||
-                this._getColumnWidthFromRatio(
+                getColumnWidth(col) ||
+                this.getColumnWidthFromRatio(
                     availableWidth,
-                    widthsMetadata,
+                    widthsData,
                     colIndex
                 );
             columnWidths[colIndex] = width;
-        });
+        }
         return columnWidths;
     }
 
     /**
-     * @private
      * Calculates column width of a given column from the ratio.
      * Clamps to `minColWidth` and `maxColWidth`.
      * Also sets housekeeping data for `colsWithMaxWidth` threshold and `colsWithMinWidth` threshold.
      *
      * @param {Number} availableWidth Available width for the table
-     * @param {Object} widthsMetadata Metadata regarding widths includes max, min, flexiblewidth, fixedwidth
+     * @param {Object} widthsData Metadata regarding widths includes max, min, flexiblewidth, fixedwidth
      * @param {Number} colIndex Column number
      */
-    _getColumnWidthFromRatio(availableWidth, widthsMetadata, colIndex) {
-        const ratios = this.columnWidthRatios;
-        const { colsWithMinWidth, colsWithMaxWidth } =
-            this.columnWidthsDistribution;
+    getColumnWidthFromRatio(availableWidth, widthsData, colIndex) {
         const {
             totalFixedWidth,
             totalResizedWidth,
             minColumnWidth,
             maxColumnWidth,
-        } = widthsMetadata;
+        } = widthsData;
+        const widthRatio = this.columnWidthRatios[colIndex];
         const totalFlexibleWidth =
             availableWidth - totalFixedWidth - totalResizedWidth;
-
-        let calculatedWidth = Math.floor(
-            (totalFlexibleWidth * ratios[colIndex]) / 100
-        );
-
-        calculatedWidth = calculatedWidth + TRUNCATION_ALLOWANCE;
-
+        const calculatedWidth =
+            Math.floor((totalFlexibleWidth * widthRatio) / 100) +
+            TRUNCATION_ALLOWANCE;
+        const { colsWithMinWidth, colsWithMaxWidth } =
+            this.columnWidthsDistribution;
         const minWidthThreshold =
             minColumnWidth + Math.ceil(MIN_MAX_THRESHOLD * minColumnWidth);
-        const maxWidthThreshold =
-            maxColumnWidth - Math.ceil(MIN_MAX_THRESHOLD * maxColumnWidth);
-
         if (calculatedWidth < minWidthThreshold) {
             colsWithMinWidth.push(colIndex);
         }
-
+        const maxWidthThreshold =
+            maxColumnWidth - Math.ceil(MIN_MAX_THRESHOLD * maxColumnWidth);
         if (calculatedWidth > maxWidthThreshold) {
             colsWithMaxWidth.push(colIndex);
         }
-
         return clamp(calculatedWidth, minColumnWidth, maxColumnWidth);
     }
 
     /**
-     * @private
      * This method gives extra width that was remaining by first giving width to columns with
      * max width or within threshold of max width then by giving from all columns possible,
      * excluding fixed width columns, columns that can become max width after redistribution.
      *
      * @param {Number} expectedTableWidth Width taken by the table in the DOM
      * @param {Array} columnWidths Column widths array
-     * @param {Object} columnDefs Column definitions from state
+     * @param {Object} columns Column definitions from state
      */
-    _redistributeExtraWidth(expectedTableWidth, columnWidths, columnDefs) {
+    redistributeExtraWidth(expectedTableWidth, columnWidths, columns) {
         const { colsWithMinWidth } = this.columnWidthsDistribution;
-
-        const widthsMetadata = getTotalWidthsMetadata(
-            this._columnWidthMetaData,
-            columnDefs
-        );
+        const { length: colsWithMinWidthLength } = colsWithMinWidth;
+        const widthsData = getTotalWidthsData(this.columnWidthData, columns);
         const { maxColumnWidth, totalResizedColumns, totalFixedColumns } =
-            widthsMetadata;
+            widthsData;
 
         let columnWidthsSum = getTotalColumnWidth(columnWidths);
-        let extraSpace = expectedTableWidth - columnWidthsSum;
-        let totalColsToDistribute = 0;
+        let extraSpace = 0;
         let extraWidthPerColumn = 0;
+        let totalColsToDistribute = 0;
 
         // First distribute space to columns with min width or threshold of min width
-        if (colsWithMinWidth.length > 0) {
-            totalColsToDistribute = colsWithMinWidth.length;
+        if (colsWithMinWidthLength > 0) {
+            extraSpace = expectedTableWidth - columnWidthsSum;
+            totalColsToDistribute = colsWithMinWidthLength;
             extraWidthPerColumn = Math.floor(
                 extraSpace / totalColsToDistribute
             );
-            colsWithMinWidth.forEach((colIndex) => {
+            for (let i = 0; i < colsWithMinWidthLength; i += 1) {
+                const colIndex = colsWithMinWidth[i];
                 const currentWidth = columnWidths[colIndex];
                 if (
                     canAddWidth(
@@ -479,26 +436,28 @@ export class AutoWidthStrategy {
                     columnWidthsSum += extraWidthPerColumn;
                     columnWidths[colIndex] = newWidth;
                 }
-            });
+            }
         }
 
         extraSpace = expectedTableWidth - columnWidthsSum;
-        const totalFixedWidthColumns = totalResizedColumns + totalFixedColumns;
 
         // Now distribute to every column possible excluding columns with defined widths
         // after this distribution its still possible we might have more space remaining
         // since we couldn't add widths to majority of columns.
         if (extraSpace > 0) {
-            totalColsToDistribute = columnDefs.length - totalFixedWidthColumns;
+            const totalFixedWidthColumns =
+                totalResizedColumns + totalFixedColumns;
+            const { length: colCount } = columns;
 
+            totalColsToDistribute = colCount - totalFixedWidthColumns;
             extraWidthPerColumn = Math.floor(
                 extraSpace / totalColsToDistribute
             );
-            columnDefs.forEach((column, colIndex) => {
+            for (let colIndex = 0; colIndex < colCount; colIndex += 1) {
+                const col = columns[colIndex];
                 const currentWidth = columnWidths[colIndex];
-
                 if (
-                    !getColumnWidthFromDef(column) &&
+                    !getColumnWidth(col) &&
                     canAddWidth(
                         currentWidth,
                         extraWidthPerColumn,
@@ -509,29 +468,25 @@ export class AutoWidthStrategy {
                     columnWidthsSum += extraWidthPerColumn;
                     columnWidths[colIndex] = newWidth;
                 }
-            });
+            }
         }
     }
 
     /**
-     * @private
      * This method removes extra space that was taken by first taking away width from columns with
      * max width or within threshold of max width then by taking away from all columns possible,
      * excluding fixed width columns, column with min width or can become min width after taking away.
      *
      * @param {Number} expectedTableWidth Width taken by the table in the DOM
      * @param {Array} columnWidths Column widths array
-     * @param {Object} columnDefs Column definitions from state
+     * @param {Object} columns Column definitions from state
      */
-    _redistributeDeficitWidth(expectedTableWidth, columnWidths, columnDefs) {
-        const { colsWithMinWidth, colsWithMaxWidth } =
-            this.columnWidthsDistribution;
-        const widthsMetadata = getTotalWidthsMetadata(
-            this._columnWidthMetaData,
-            columnDefs
-        );
+    redistributeDeficitWidth(expectedTableWidth, columnWidths, columns) {
+        const { colsWithMaxWidth } = this.columnWidthsDistribution;
+        const { length: colsWithMaxWidthLength } = colsWithMaxWidth;
+        const widthsData = getTotalWidthsData(this.columnWidthData, columns);
         const { minColumnWidth, totalResizedColumns, totalFixedColumns } =
-            widthsMetadata;
+            widthsData;
 
         let columnWidthsSum = getTotalColumnWidth(columnWidths);
         let extraSpace = expectedTableWidth - columnWidthsSum;
@@ -539,14 +494,14 @@ export class AutoWidthStrategy {
         let extraWidthPerColumn = 0;
 
         // First take away width from columns with max width or threshold of max width
-        if (colsWithMaxWidth.length > 0) {
-            totalColsToDistribute = colsWithMaxWidth.length;
+        if (colsWithMaxWidthLength > 0) {
+            totalColsToDistribute = colsWithMaxWidthLength;
             extraWidthPerColumn = Math.floor(
                 Math.abs(extraSpace) / totalColsToDistribute
             );
-            colsWithMaxWidth.forEach((colIndex) => {
+            for (let i = 0, { length } = colsWithMaxWidth; i < length; i += 1) {
+                const colIndex = colsWithMaxWidth[i];
                 const currentWidth = columnWidths[colIndex];
-
                 if (
                     canRemoveWidth(
                         currentWidth,
@@ -558,7 +513,7 @@ export class AutoWidthStrategy {
                     columnWidthsSum -= extraWidthPerColumn;
                     columnWidths[colIndex] = newWidth;
                 }
-            });
+            }
         }
 
         extraSpace = expectedTableWidth - columnWidthsSum;
@@ -567,20 +522,21 @@ export class AutoWidthStrategy {
         // Now from every column possible excluding columns with defined widths
         // and excluding columns within minWidthThreshold
         // after this distribution its still possible we might have used more space
-        // since we couldnt take away widths from majority of columns
+        // since we couldn't take away widths from majority of columns
         if (extraSpace < 0) {
+            const { colsWithMinWidth } = this.columnWidthsDistribution;
             totalColsToDistribute =
-                columnDefs.length -
+                columns.length -
                 (totalFixedWidthColumns + colsWithMinWidth.length);
             extraWidthPerColumn = Math.floor(
                 Math.abs(extraSpace) / totalColsToDistribute
             );
-            columnDefs.forEach((column, colIndex) => {
+            for (let colIndex = 0; colIndex < columns.length; colIndex += 1) {
+                const col = columns[colIndex];
                 const currentWidth = columnWidths[colIndex];
-
                 if (
-                    !getColumnWidthFromDef(column) &&
                     !hasColumn(colsWithMinWidth, colIndex) &&
+                    !getColumnWidth(col) &&
                     canRemoveWidth(
                         currentWidth,
                         extraWidthPerColumn,
@@ -591,7 +547,7 @@ export class AutoWidthStrategy {
                     columnWidthsSum -= extraWidthPerColumn;
                     columnWidths[colIndex] = newWidth;
                 }
-            });
+            }
         }
     }
 }