handsontable 0.0.0-next-8951d31-20250210 → 0.0.0-next-508ffe1-20250211

package/3rdparty/walkontable/src/calculator/viewportColumns.js

@@ -85,7 +85,11 @@ class ViewportColumnsCalculator extends _viewportBase.ViewportBaseCalculator {
    * @returns {number}
    */
   getColumnWidth(column) {
-    return this.columnWidthFn(column);
+    const width = this.columnWidthFn(column);
+    if (isNaN(width)) {
+      return DEFAULT_WIDTH;
+    }
+    return width;
   }
 }
 exports.ViewportColumnsCalculator = ViewportColumnsCalculator;

package/3rdparty/walkontable/src/calculator/viewportColumns.mjs

@@ -82,6 +82,10 @@ export class ViewportColumnsCalculator extends ViewportBaseCalculator {
    * @returns {number}
    */
   getColumnWidth(column) {
-    return this.columnWidthFn(column);
+    const width = this.columnWidthFn(column);
+    if (isNaN(width)) {
+      return DEFAULT_WIDTH;
+    }
+    return width;
   }
 }

package/3rdparty/walkontable/src/calculator/viewportRows.js

@@ -87,7 +87,11 @@ class ViewportRowsCalculator extends _viewportBase.ViewportBaseCalculator {
    * @returns {number}
    */
   getRowHeight(row) {
-    return this.rowHeightFn(row);
+    const rowHeight = this.rowHeightFn(row);
+    if (isNaN(rowHeight)) {
+      return this.defaultHeight;
+    }
+    return rowHeight;
   }
 }
 exports.ViewportRowsCalculator = ViewportRowsCalculator;

package/3rdparty/walkontable/src/calculator/viewportRows.mjs

@@ -84,6 +84,10 @@ export class ViewportRowsCalculator extends ViewportBaseCalculator {
    * @returns {number}
    */
   getRowHeight(row) {
-    return this.rowHeightFn(row);
+    const rowHeight = this.rowHeightFn(row);
+    if (isNaN(rowHeight)) {
+      return this.defaultHeight;
+    }
+    return rowHeight;
   }
 }

package/3rdparty/walkontable/src/overlay/inlineStart.js

@@ -115,7 +115,14 @@ class InlineStartOverlay extends _base.Overlay {
    * @returns {number} Width sum.
    */
   sumCellSizes(from, to) {
-    return (to - from) * 80;
+    const defaultColumnWidth = this.wtSettings.getSetting('defaultColumnWidth');
+    let column = from;
+    let sum = 0;
+    while (column < to) {
+      sum += this.wot.wtTable.getColumnWidth(column) || defaultColumnWidth;
+      column += 1;
+    }
+    return sum;
   }
 
   /**

package/3rdparty/walkontable/src/overlay/inlineStart.mjs

@@ -111,7 +111,14 @@ export class InlineStartOverlay extends Overlay {
    * @returns {number} Width sum.
    */
   sumCellSizes(from, to) {
-    return (to - from) * 80;
+    const defaultColumnWidth = this.wtSettings.getSetting('defaultColumnWidth');
+    let column = from;
+    let sum = 0;
+    while (column < to) {
+      sum += this.wot.wtTable.getColumnWidth(column) || defaultColumnWidth;
+      column += 1;
+    }
+    return sum;
   }
 
   /**

package/3rdparty/walkontable/src/overlay/top.js

@@ -138,7 +138,15 @@ class TopOverlay extends _base.Overlay {
    * @returns {number} Height sum.
    */
   sumCellSizes(from, to) {
-    return (to - from) * 29;
+    const defaultRowHeight = this.wot.stylesHandler.getDefaultRowHeight();
+    let row = from;
+    let sum = 0;
+    while (row < to) {
+      const height = this.wot.wtTable.getRowHeight(row);
+      sum += height === undefined ? defaultRowHeight : height;
+      row += 1;
+    }
+    return sum;
   }
 
   /**

package/3rdparty/walkontable/src/overlay/top.mjs

@@ -134,7 +134,15 @@ export class TopOverlay extends Overlay {
    * @returns {number} Height sum.
    */
   sumCellSizes(from, to) {
-    return (to - from) * 29;
+    const defaultRowHeight = this.wot.stylesHandler.getDefaultRowHeight();
+    let row = from;
+    let sum = 0;
+    while (row < to) {
+      const height = this.wot.wtTable.getRowHeight(row);
+      sum += height === undefined ? defaultRowHeight : height;
+      row += 1;
+    }
+    return sum;
   }
 
   /**

package/3rdparty/walkontable/src/renderer/cells.js

@@ -72,14 +72,11 @@ class CellsRenderer extends _base.BaseRenderer {
       this.sourceRowIndex = sourceRowIndex;
       const orderView = this.obtainOrderView(TR);
       const rowHeadersView = rowHeaders.obtainOrderView(TR);
-      orderView.prependView(rowHeadersView).setSize(columnsToRender).setOffset(this.table.renderedColumnToSource(0)).start();
+      orderView.prependView(rowHeadersView).setSize(columnsToRender).setOffset(0).start();
       for (let visibleColumnIndex = 0; visibleColumnIndex < columnsToRender; visibleColumnIndex++) {
         orderView.render();
         const sourceColumnIndex = this.table.renderedColumnToSource(visibleColumnIndex);
         const TD = orderView.getCurrentNode();
-        if (TD.innerHTML !== '') {
-          continue;
-        }
         if (!(0, _element.hasClass)(TD, 'hide')) {
           // Workaround for hidden columns plugin
           TD.className = '';

package/3rdparty/walkontable/src/renderer/cells.mjs

@@ -69,14 +69,11 @@ export class CellsRenderer extends BaseRenderer {
       this.sourceRowIndex = sourceRowIndex;
       const orderView = this.obtainOrderView(TR);
       const rowHeadersView = rowHeaders.obtainOrderView(TR);
-      orderView.prependView(rowHeadersView).setSize(columnsToRender).setOffset(this.table.renderedColumnToSource(0)).start();
+      orderView.prependView(rowHeadersView).setSize(columnsToRender).setOffset(0).start();
       for (let visibleColumnIndex = 0; visibleColumnIndex < columnsToRender; visibleColumnIndex++) {
         orderView.render();
         const sourceColumnIndex = this.table.renderedColumnToSource(visibleColumnIndex);
         const TD = orderView.getCurrentNode();
-        if (TD.innerHTML !== '') {
-          continue;
-        }
         if (!hasClass(TD, 'hide')) {
           // Workaround for hidden columns plugin
           TD.className = '';

package/3rdparty/walkontable/src/renderer/columnHeaders.js

@@ -18,7 +18,7 @@ var _a11y = require("../../../../helpers/a11y");
  */
 class ColumnHeadersRenderer extends _base.BaseRenderer {
   constructor(rootNode) {
-    super('TR', rootNode); // NodePool is not implemented for this renderer yet
+    super(null, rootNode); // NodePool is not implemented for this renderer yet
   }
 
   /**
@@ -86,9 +86,6 @@ class ColumnHeadersRenderer extends _base.BaseRenderer {
         // eslint-disable-line max-len
         const sourceColumnIndex = this.table.renderedColumnToSource(renderedColumnIndex);
         const TH = TR.childNodes[renderedColumnIndex + rowHeadersCount];
-        if (TH.innerHTML !== '') {
-          continue;
-        }
         TH.className = '';
         TH.removeAttribute('style');
 

package/3rdparty/walkontable/src/renderer/columnHeaders.mjs

@@ -15,7 +15,7 @@ import { A11Y_COLINDEX, A11Y_COLUMNHEADER, A11Y_ROW, A11Y_ROWGROUP, A11Y_ROWINDE
  */
 export class ColumnHeadersRenderer extends BaseRenderer {
   constructor(rootNode) {
-    super('TR', rootNode); // NodePool is not implemented for this renderer yet
+    super(null, rootNode); // NodePool is not implemented for this renderer yet
   }
 
   /**
@@ -83,9 +83,6 @@ export class ColumnHeadersRenderer extends BaseRenderer {
         // eslint-disable-line max-len
         const sourceColumnIndex = this.table.renderedColumnToSource(renderedColumnIndex);
         const TH = TR.childNodes[renderedColumnIndex + rowHeadersCount];
-        if (TH.innerHTML !== '') {
-          continue;
-        }
         TH.className = '';
         TH.removeAttribute('style');
 

package/3rdparty/walkontable/src/renderer/rowHeaders.js

@@ -77,9 +77,6 @@ class RowHeadersRenderer extends _base.BaseRenderer {
       for (let visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) {
         orderView.render();
         const TH = orderView.getCurrentNode();
-        if (TH.innerHTML !== '') {
-          continue;
-        }
         TH.className = '';
         TH.removeAttribute('style');
 

package/3rdparty/walkontable/src/renderer/rowHeaders.mjs

@@ -74,9 +74,6 @@ export class RowHeadersRenderer extends BaseRenderer {
       for (let visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) {
         orderView.render();
         const TH = orderView.getCurrentNode();
-        if (TH.innerHTML !== '') {
-          continue;
-        }
         TH.className = '';
         TH.removeAttribute('style');
 

package/3rdparty/walkontable/src/table.js

@@ -300,6 +300,16 @@ class Table {
         this.resetOversizedRows();
         this.tableRenderer.setActiveOverlayName(this.name).setViewportSize(this.getRenderedRowsCount(), this.getRenderedColumnsCount()).setFilters(this.rowFilter, this.columnFilter).render();
         if (this.isMaster) {
+          this.markOversizedColumnHeaders();
+        }
+        this.adjustColumnHeaderHeights();
+        if (this.isMaster || this.is(_overlay.CLONE_BOTTOM)) {
+          this.markOversizedRows();
+        }
+        if (this.isMaster) {
+          if (!this.wtSettings.getSetting('externalRowCalculator')) {
+            wtViewport.createVisibleCalculators();
+          }
           wtOverlays.refresh(false);
           wtOverlays.applyToDOM();
           this.wtSettings.getSetting('onDraw', true);
@@ -341,18 +351,85 @@ class Table {
   /**
    * @param {number} col The visual column index.
    */
-  markIfOversizedColumnHeader(col) {}
+  markIfOversizedColumnHeader(col) {
+    const sourceColIndex = this.columnFilter.renderedToSource(col);
+    let level = this.wtSettings.getSetting('columnHeaders').length;
+    const defaultRowHeight = this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    let previousColHeaderHeight;
+    let currentHeader;
+    let currentHeaderHeight;
+    const columnHeaderHeightSetting = this.wtSettings.getSetting('columnHeaderHeight') || [];
+    while (level) {
+      level -= 1;
+      previousColHeaderHeight = this.getColumnHeaderHeight(level);
+      currentHeader = this.getColumnHeader(sourceColIndex, level);
+      if (!currentHeader) {
+        /* eslint-disable no-continue */
+        continue;
+      }
+      currentHeaderHeight = (0, _element.innerHeight)(currentHeader);
+      if (!previousColHeaderHeight && defaultRowHeight < currentHeaderHeight || previousColHeaderHeight < currentHeaderHeight) {
+        this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = currentHeaderHeight;
+      }
+      if (Array.isArray(columnHeaderHeightSetting)) {
+        if (columnHeaderHeightSetting[level] !== null && columnHeaderHeightSetting[level] !== undefined) {
+          this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level];
+        }
+      } else if (!isNaN(columnHeaderHeightSetting)) {
+        this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting;
+      }
+      if (this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] < (columnHeaderHeightSetting[level] || columnHeaderHeightSetting)) {
+        this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level] || columnHeaderHeightSetting; // eslint-disable-line max-len
+      }
+    }
+  }
 
   /**
    *
    */
-  adjustColumnHeaderHeights() {}
+  adjustColumnHeaderHeights() {
+    const {
+      wtSettings
+    } = this;
+    const children = this.THEAD.childNodes;
+    const oversizedColumnHeaders = this.dataAccessObject.wtViewport.oversizedColumnHeaders;
+    const columnHeaders = wtSettings.getSetting('columnHeaders');
+    for (let i = 0, len = columnHeaders.length; i < len; i++) {
+      if (oversizedColumnHeaders[i]) {
+        if (!children[i] || children[i].childNodes.length === 0) {
+          return;
+        }
+        children[i].childNodes[0].style.height = `${oversizedColumnHeaders[i]}px`;
+      }
+    }
+  }
 
   /**
    * Resets cache of row heights. The cache should be cached for each render cycle in a case
    * when new cell values have content which increases/decreases cell height.
    */
-  resetOversizedRows() {}
+  resetOversizedRows() {
+    const {
+      wtSettings
+    } = this;
+    const {
+      wtViewport
+    } = this.dataAccessObject;
+    if (!this.isMaster && !this.is(_overlay.CLONE_BOTTOM)) {
+      return;
+    }
+    if (!wtSettings.getSetting('externalRowCalculator')) {
+      const rowsToRender = this.getRenderedRowsCount();
+
+      // Reset the oversized row cache for rendered rows
+      for (let visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
+        const sourceRow = this.rowFilter.renderedToSource(visibleRowIndex);
+        if (wtViewport.oversizedRows && wtViewport.oversizedRows[sourceRow]) {
+          wtViewport.oversizedRows[sourceRow] = undefined;
+        }
+      }
+    }
+  }
 
   /**
    * Get cell element at coords.
@@ -550,7 +627,46 @@ class Table {
   /**
    * Check if any of the rendered rows is higher than expected, and if so, cache them.
    */
-  markOversizedRows() {}
+  markOversizedRows() {
+    if (this.wtSettings.getSetting('externalRowCalculator')) {
+      return;
+    }
+    let rowCount = this.TBODY.childNodes.length;
+    const expectedTableHeight = rowCount * this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    const actualTableHeight = (0, _element.innerHeight)(this.TBODY) - 1;
+    const borderBoxSizing = this.wot.stylesHandler.areCellsBorderBox();
+    const rowHeightFn = borderBoxSizing ? _element.outerHeight : _element.innerHeight;
+    const borderCompensation = borderBoxSizing ? 0 : 1;
+    const firstRowBorderCompensation = borderBoxSizing ? 1 : 0;
+    let previousRowHeight;
+    let rowCurrentHeight;
+    let sourceRowIndex;
+    let currentTr;
+    let rowHeader;
+    if (expectedTableHeight === actualTableHeight && !this.wtSettings.getSetting('fixedRowsBottom')) {
+      // If the actual table height equals rowCount * default single row height, no row is oversized -> no need to iterate over them
+      return;
+    }
+    while (rowCount) {
+      rowCount -= 1;
+      sourceRowIndex = this.rowFilter.renderedToSource(rowCount);
+      previousRowHeight = this.getRowHeight(sourceRowIndex);
+      currentTr = this.getTrForRow(sourceRowIndex);
+      rowHeader = currentTr.querySelector('th');
+      const topBorderCompensation = sourceRowIndex === 0 ? firstRowBorderCompensation : 0;
+      if (rowHeader) {
+        rowCurrentHeight = rowHeightFn(rowHeader);
+      } else {
+        rowCurrentHeight = rowHeightFn(currentTr) - borderCompensation;
+      }
+      if (!previousRowHeight && this.dataAccessObject.stylesHandler.getDefaultRowHeight() < rowCurrentHeight - topBorderCompensation || previousRowHeight < rowCurrentHeight) {
+        if (!borderBoxSizing) {
+          rowCurrentHeight += 1;
+        }
+        this.dataAccessObject.wtViewport.oversizedRows[sourceRowIndex] = rowCurrentHeight;
+      }
+    }
+  }
 
   /**
    * @param {number} row The visual row index.
@@ -865,7 +981,32 @@ class Table {
    * @returns {number}
    */
   _modifyRowHeaderWidth(rowHeaderWidthFactory) {
-    return 50;
+    let widths = (0, _function.isFunction)(rowHeaderWidthFactory) ? rowHeaderWidthFactory() : null;
+    if (Array.isArray(widths)) {
+      widths = [...widths];
+      widths[widths.length - 1] = this._correctRowHeaderWidth(widths[widths.length - 1]);
+    } else {
+      widths = this._correctRowHeaderWidth(widths);
+    }
+    return widths;
+  }
+
+  /**
+   * Correct row header width if necessary.
+   *
+   * @private
+   * @param {number} width The width to process.
+   * @returns {number}
+   */
+  _correctRowHeaderWidth(width) {
+    let rowHeaderWidth = width;
+    if (typeof width !== 'number') {
+      rowHeaderWidth = this.wtSettings.getSetting('defaultColumnWidth');
+    }
+    if (this.correctHeaderWidth) {
+      rowHeaderWidth += 1;
+    }
+    return rowHeaderWidth;
   }
 }
 var _default = exports.default = Table;

package/3rdparty/walkontable/src/table.mjs

@@ -296,6 +296,16 @@ class Table {
         this.resetOversizedRows();
         this.tableRenderer.setActiveOverlayName(this.name).setViewportSize(this.getRenderedRowsCount(), this.getRenderedColumnsCount()).setFilters(this.rowFilter, this.columnFilter).render();
         if (this.isMaster) {
+          this.markOversizedColumnHeaders();
+        }
+        this.adjustColumnHeaderHeights();
+        if (this.isMaster || this.is(CLONE_BOTTOM)) {
+          this.markOversizedRows();
+        }
+        if (this.isMaster) {
+          if (!this.wtSettings.getSetting('externalRowCalculator')) {
+            wtViewport.createVisibleCalculators();
+          }
           wtOverlays.refresh(false);
           wtOverlays.applyToDOM();
           this.wtSettings.getSetting('onDraw', true);
@@ -337,18 +347,85 @@ class Table {
   /**
    * @param {number} col The visual column index.
    */
-  markIfOversizedColumnHeader(col) {}
+  markIfOversizedColumnHeader(col) {
+    const sourceColIndex = this.columnFilter.renderedToSource(col);
+    let level = this.wtSettings.getSetting('columnHeaders').length;
+    const defaultRowHeight = this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    let previousColHeaderHeight;
+    let currentHeader;
+    let currentHeaderHeight;
+    const columnHeaderHeightSetting = this.wtSettings.getSetting('columnHeaderHeight') || [];
+    while (level) {
+      level -= 1;
+      previousColHeaderHeight = this.getColumnHeaderHeight(level);
+      currentHeader = this.getColumnHeader(sourceColIndex, level);
+      if (!currentHeader) {
+        /* eslint-disable no-continue */
+        continue;
+      }
+      currentHeaderHeight = innerHeight(currentHeader);
+      if (!previousColHeaderHeight && defaultRowHeight < currentHeaderHeight || previousColHeaderHeight < currentHeaderHeight) {
+        this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = currentHeaderHeight;
+      }
+      if (Array.isArray(columnHeaderHeightSetting)) {
+        if (columnHeaderHeightSetting[level] !== null && columnHeaderHeightSetting[level] !== undefined) {
+          this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level];
+        }
+      } else if (!isNaN(columnHeaderHeightSetting)) {
+        this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting;
+      }
+      if (this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] < (columnHeaderHeightSetting[level] || columnHeaderHeightSetting)) {
+        this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level] || columnHeaderHeightSetting; // eslint-disable-line max-len
+      }
+    }
+  }
 
   /**
    *
    */
-  adjustColumnHeaderHeights() {}
+  adjustColumnHeaderHeights() {
+    const {
+      wtSettings
+    } = this;
+    const children = this.THEAD.childNodes;
+    const oversizedColumnHeaders = this.dataAccessObject.wtViewport.oversizedColumnHeaders;
+    const columnHeaders = wtSettings.getSetting('columnHeaders');
+    for (let i = 0, len = columnHeaders.length; i < len; i++) {
+      if (oversizedColumnHeaders[i]) {
+        if (!children[i] || children[i].childNodes.length === 0) {
+          return;
+        }
+        children[i].childNodes[0].style.height = `${oversizedColumnHeaders[i]}px`;
+      }
+    }
+  }
 
   /**
    * Resets cache of row heights. The cache should be cached for each render cycle in a case
    * when new cell values have content which increases/decreases cell height.
    */
-  resetOversizedRows() {}
+  resetOversizedRows() {
+    const {
+      wtSettings
+    } = this;
+    const {
+      wtViewport
+    } = this.dataAccessObject;
+    if (!this.isMaster && !this.is(CLONE_BOTTOM)) {
+      return;
+    }
+    if (!wtSettings.getSetting('externalRowCalculator')) {
+      const rowsToRender = this.getRenderedRowsCount();
+
+      // Reset the oversized row cache for rendered rows
+      for (let visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
+        const sourceRow = this.rowFilter.renderedToSource(visibleRowIndex);
+        if (wtViewport.oversizedRows && wtViewport.oversizedRows[sourceRow]) {
+          wtViewport.oversizedRows[sourceRow] = undefined;
+        }
+      }
+    }
+  }
 
   /**
    * Get cell element at coords.
@@ -546,7 +623,46 @@ class Table {
   /**
    * Check if any of the rendered rows is higher than expected, and if so, cache them.
    */
-  markOversizedRows() {}
+  markOversizedRows() {
+    if (this.wtSettings.getSetting('externalRowCalculator')) {
+      return;
+    }
+    let rowCount = this.TBODY.childNodes.length;
+    const expectedTableHeight = rowCount * this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    const actualTableHeight = innerHeight(this.TBODY) - 1;
+    const borderBoxSizing = this.wot.stylesHandler.areCellsBorderBox();
+    const rowHeightFn = borderBoxSizing ? outerHeight : innerHeight;
+    const borderCompensation = borderBoxSizing ? 0 : 1;
+    const firstRowBorderCompensation = borderBoxSizing ? 1 : 0;
+    let previousRowHeight;
+    let rowCurrentHeight;
+    let sourceRowIndex;
+    let currentTr;
+    let rowHeader;
+    if (expectedTableHeight === actualTableHeight && !this.wtSettings.getSetting('fixedRowsBottom')) {
+      // If the actual table height equals rowCount * default single row height, no row is oversized -> no need to iterate over them
+      return;
+    }
+    while (rowCount) {
+      rowCount -= 1;
+      sourceRowIndex = this.rowFilter.renderedToSource(rowCount);
+      previousRowHeight = this.getRowHeight(sourceRowIndex);
+      currentTr = this.getTrForRow(sourceRowIndex);
+      rowHeader = currentTr.querySelector('th');
+      const topBorderCompensation = sourceRowIndex === 0 ? firstRowBorderCompensation : 0;
+      if (rowHeader) {
+        rowCurrentHeight = rowHeightFn(rowHeader);
+      } else {
+        rowCurrentHeight = rowHeightFn(currentTr) - borderCompensation;
+      }
+      if (!previousRowHeight && this.dataAccessObject.stylesHandler.getDefaultRowHeight() < rowCurrentHeight - topBorderCompensation || previousRowHeight < rowCurrentHeight) {
+        if (!borderBoxSizing) {
+          rowCurrentHeight += 1;
+        }
+        this.dataAccessObject.wtViewport.oversizedRows[sourceRowIndex] = rowCurrentHeight;
+      }
+    }
+  }
 
   /**
    * @param {number} row The visual row index.
@@ -861,7 +977,32 @@ class Table {
    * @returns {number}
    */
   _modifyRowHeaderWidth(rowHeaderWidthFactory) {
-    return 50;
+    let widths = isFunction(rowHeaderWidthFactory) ? rowHeaderWidthFactory() : null;
+    if (Array.isArray(widths)) {
+      widths = [...widths];
+      widths[widths.length - 1] = this._correctRowHeaderWidth(widths[widths.length - 1]);
+    } else {
+      widths = this._correctRowHeaderWidth(widths);
+    }
+    return widths;
+  }
+
+  /**
+   * Correct row header width if necessary.
+   *
+   * @private
+   * @param {number} width The width to process.
+   * @returns {number}
+   */
+  _correctRowHeaderWidth(width) {
+    let rowHeaderWidth = width;
+    if (typeof width !== 'number') {
+      rowHeaderWidth = this.wtSettings.getSetting('defaultColumnWidth');
+    }
+    if (this.correctHeaderWidth) {
+      rowHeaderWidth += 1;
+    }
+    return rowHeaderWidth;
   }
 }
 export default Table;

package/3rdparty/walkontable/src/utils/column.js

@@ -39,7 +39,8 @@ class ColumnUtils {
    * @returns {number}
    */
   getWidth(sourceIndex) {
-    return this.wtSettings.getSetting('columnWidth', sourceIndex);
+    const width = this.wtSettings.getSetting('columnWidth', sourceIndex) || this.wtSettings.getSetting('defaultColumnWidth');
+    return width;
   }
 
   /**
@@ -49,7 +50,12 @@ class ColumnUtils {
    * @returns {number}
    */
   getHeaderHeight(level) {
-    return this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    let height = this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    const oversizedHeight = this.dataAccessObject.wtViewport.oversizedColumnHeaders[level];
+    if (oversizedHeight !== undefined) {
+      height = height ? Math.max(height, oversizedHeight) : oversizedHeight;
+    }
+    return height;
   }
 
   /**
@@ -59,12 +65,27 @@ class ColumnUtils {
    * @returns {number}
    */
   getHeaderWidth(sourceIndex) {
-    return 50;
+    return this.headerWidths.get(this.dataAccessObject.wtTable.columnFilter.sourceToRendered(sourceIndex));
   }
 
   /**
    * Calculates column header widths that can be retrieved from the cache.
    */
-  calculateWidths() {}
+  calculateWidths() {
+    const {
+      wtSettings
+    } = this;
+    let rowHeaderWidthSetting = wtSettings.getSetting('rowHeaderWidth');
+    rowHeaderWidthSetting = wtSettings.getSetting('onModifyRowHeaderWidth', rowHeaderWidthSetting);
+    if (rowHeaderWidthSetting !== null && rowHeaderWidthSetting !== undefined) {
+      const rowHeadersCount = wtSettings.getSetting('rowHeaders').length;
+      const defaultColumnWidth = wtSettings.getSetting('defaultColumnWidth');
+      for (let visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) {
+        let width = Array.isArray(rowHeaderWidthSetting) ? rowHeaderWidthSetting[visibleColumnIndex] : rowHeaderWidthSetting;
+        width = width === null || width === undefined ? defaultColumnWidth : width;
+        this.headerWidths.set(visibleColumnIndex, width);
+      }
+    }
+  }
 }
 exports.default = ColumnUtils;