ExcelJS автоматическая высота строки

import ExcelJS from 'exceljs';
 
class Char {
    public constructor(value: string) {
        this._value = value[0];
    }
 
    // Проверено на шрифте Times New Roman, 11pt
    public getWidth(): number {
        if (this._width)
            return this._width * Char._widthMultiplier;
 
        const widthFound = Char._widths.find(([chars]) => chars.includes(this.value));
        this._width = widthFound?.[1] ?? Char._defaultWidth;
 
        return this.getWidth();
    }
 
    public static getHeight(): number {
        return Char._height;
    }
 
    public isSeparator(): boolean {
        return Char._separators.includes(this.value);
    }
 
    public get value(): string {
        return this._value;
    }
 
 
    private readonly _value: string;
    private _width: number | undefined;
    private static readonly _widthMultiplier = 1;
    private static readonly _height = 14;
 
    private static readonly _defaultWidth = 2;
    // Исходя из количества символов на 100 единиц ширины столбца
    private static readonly _widths: readonly [readonly string[], number][] = [
        [['Ш', 'Щ', 'Ю'], 1.786], // 56
        [['@', 'W'], 1.667], // 60
        [['М', 'M', 'Ы', 'Ж'], 1.563], // 64
        [['Ф', '%'], 1.449], // 69
        [['А', 'Х', '&', 'A', 'D', 'G', 'H', 'K', 'N', 'O', 'Q', 'U', 'V', 'X', 'Y',
            'm', 'w', 'И', 'Й', 'Н', 'О', 'П', 'Ц', 'ю', 'ш', 'щ'], 1.333], // 75
        [['К', 'У', 'B', 'C', 'R', 'В', 'Д', 'Л', 'ж', 'С', 'Э', 'Я', 'ы', 'Ъ'], 1.22], // 82
        [['E', 'L', 'T', 'Z', 'Т', 'Е', 'Ё', 'Ч', 'м', 'ф'], 1.111], // 90
        [['+', '<', '=', '>', 'F', 'P', 'S', '~', 'Г', 'и', 'й', 'н', 'п', 'ц', 'Б', 'Р', 'Ь'], 1], // 100
        [['\\', 'к', '#', '$', '*', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '^', '_', 'b', 'd', 'g', 'h', 'k', 'n', 'o', 'p', 'q', 'u', 'v', 'x', 'y',
            '{', '}', 'у', 'х', 'ч', 'б', 'в', 'д', 'л', 'о', 'р', 'З', 'ъ'], 0.885], // 113
        [['г', ' ', '"', '?', 'a', 'c', 'e', 'z', 'т', 'с', 'ь', 'э', 'а', 'е', 'ё', 'я'], 0.775], // 129
        [['s', 'J', 'з'], 0.662], // 151
        [['!', '(', ')', '-', 'I', '[', ']', '`', 'f', 'r'], 0.552], // 181
        [[',', '.', '/', ':', ';', 'i', 'j', 'l', 't'], 0.442], // 226
        [['\'', '|'], 0.332] // 301
    ];
 
    private static readonly _separators: readonly string[] = ['!', '?', ' ', ',', '.', '-'];
}
 
export class Cell {
    constructor(excelJSCell: ExcelJS.Cell) {
        this._excelJSCell = excelJSCell;
    }
 
    public getHeight(): number {
        if (this._height)
            return this._height;
 
        const worksheet = this.excelJSCell.worksheet;
        const value = this.excelJSCell.value;
        const column = worksheet.getColumn(this.excelJSCell.col);
        const maxWidth = column.width ?? worksheet.properties.defaultColWidth;
        if (!maxWidth)
            throw new Error('Cell: !maxWidth');
 
        let currentLineWidth = 0;
        let widthToSeparator = 0;
        let rowsCount = 1;
 
        const chars = Array.from(String(value));
        chars.forEach(charValue => {
            const char = new Char(charValue);
 
            currentLineWidth += char.getWidth();
            widthToSeparator += char.getWidth();
 
            if (char.isSeparator()) {
                widthToSeparator = 0;
            }
 
            if (currentLineWidth > maxWidth) {
                currentLineWidth = widthToSeparator;
                rowsCount++;
            }
        });
 
        this._height = Math.max(rowsCount * Char.getHeight(), 1);
 
        return this.getHeight();
    }
 
    public get excelJSCell(): ExcelJS.Cell {
        return this._excelJSCell;
    }
 
    public getExcelJSCell(): ExcelJS.Cell {
        return this.excelJSCell;
    }
 
    public static from(excelJSCell: ExcelJS.Cell): Cell {
        return new Cell(excelJSCell);
    }
 
 
    private _height: number | undefined;
    private readonly _excelJSCell: ExcelJS.Cell;
}
 
export class Row {
    public static from(excelJSRow: ExcelJS.Row): Row {
        return new Row(excelJSRow);
    }
 
    public toBold(): Row {
        this.forEachCells(cell => {
            !cell.style.font && (cell.style.font = {});
            cell.style.font.bold = true;
        });
 
        return this;
    }
 
    public toLeft(): Row {
        this.forEachCells(cell => {
            !cell.style.alignment && (cell.style.alignment = {});
            cell.style.alignment.horizontal = 'left';
        });
 
        return this;
    }
 
    public merge(firstIndex: number, secondIndex: number): Row {
        this.excelJSRow.worksheet.mergeCells(
            this.excelJSRow.getCell(firstIndex).address,
            this.excelJSRow.getCell(secondIndex).address
        );
 
        return this;
    }
 
    public setAutoHeight(): Row {
        const cells = this.getCells();
        const heights = cells.map(cell => cell.getHeight());
 
        this.excelJSRow.height = Math.max(...heights);
 
        return this;
    }
 
    public setHeight(height: number): Row {
        this.excelJSRow.height = height;
 
        return this;
    }
 
    public showBorders(): Row {
        this.forEachCells(cell => {
            cell.style.border = {
                left: {style: 'thin'},
                top: {style: 'thin'},
                right: {style: 'thin'},
                bottom: {style: 'thin'}
            };
        });
 
        return this;
    }
 
    public forEachCells(callback: (cell: ExcelJS.Cell) => any): Row {
        this.getValues().forEach((value, index) =>
            callback(this.excelJSRow.getCell(index)));
 
        return this;
    }
 
    public getValues(): ExcelJS.CellValue[] {
        return Array.isArray(this.excelJSRow.values)
            ? this.excelJSRow.values
            : Object.values(this.excelJSRow.values);
    }
 
    public get excelJSRow(): ExcelJS.Row {
        return this._excelJSRow;
    }
 
    public getExcelJSRow(): ExcelJS.Row {
        return this.excelJSRow;
    }
 
    public getCells(): Cell[] {
        const cells: Cell[] = [];
        this.excelJSRow.eachCell(excelJSCell => cells.push(new Cell(excelJSCell)));
 
        return cells;
    }
 
 
    private readonly _excelJSRow: ExcelJS.Row;
 
    private constructor(excelJSRow: ExcelJS.Row) {
        this._excelJSRow = excelJSRow;
 
        if (this.excelJSRow.getCell(1).font?.name === 'Times New Roman')
            return;
 
        this.forEachCells(cell => {
            cell.style = {
                font: {
                    name: 'Times New Roman',
                    size: 12,
                    bold: false
                }
            };
 
            cell.alignment = {
                horizontal: 'center',
                vertical: 'middle',
                wrapText: true
            };
        });
    }
}
 
export class Excel {
    public readonly columnsCount: number;
    public readonly workbook: ExcelJS.Workbook;
    public readonly worksheet: ExcelJS.Worksheet;
    public readonly rows: Row[] = [];
 
    public constructor(
        name: string,
        widthColumns: number[]
    ) {
        this.workbook = new ExcelJS.Workbook();
        this.worksheet = this.workbook.addWorksheet(name, {
            pageSetup: {paperSize: 9}
        });
 
        this.worksheet.columns = widthColumns.map(width => ({width}));
 
        this.columnsCount = widthColumns.length;
    }
 
    public addRow(...values: ExcelJS.CellValue[]): Row {
        const newExcelJSRow = this.worksheet.addRow(values);
        const newRow = Row.from(newExcelJSRow);
 
        this.rows.push(newRow);
 
        return newRow;
    }
}