@contrail/document-table 1.0.1

package/lib/table.service.js

@@ -0,0 +1,630 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableService = exports.createCell = exports.tableData = exports.TABLE_ERROR = void 0;
+const util_1 = require("@contrail/util");
+const nanoid_1 = require("nanoid");
+const util_2 = require("@contrail/util");
+const table_constants_1 = require("./table-constants");
+const table_merge_service_1 = require("./table-merge.service");
+const table_range_1 = require("./table-range");
+var TABLE_ERROR;
+(function (TABLE_ERROR) {
+    TABLE_ERROR["UNMERGE_TO_DELETE_COLUMN"] = "Unmerge cells to delete column";
+    TABLE_ERROR["UNMERGE_TO_DELETE_ROW"] = "Unmerge cells to delete row";
+    TABLE_ERROR["UMMERGE_TO_MOVE_COLUMN"] = "Unmerge cells to move column";
+    TABLE_ERROR["UMMERGE_TO_MOVE_ROW"] = "Unmerge cells to move row";
+    TABLE_ERROR["INVALID_RANGE_TO_MERGE"] = "Invalid range to merge";
+    TABLE_ERROR["INVALID_RANGE_TO_UNMERGE"] = "Invalid range to unmerge";
+    TABLE_ERROR["INVALID_TABLE"] = "Invalid table";
+})(TABLE_ERROR = exports.TABLE_ERROR || (exports.TABLE_ERROR = {}));
+function tableData(element) {
+    return {
+        id: element.id,
+        tableId: element.type === 'table' ? element.id : element.tableId,
+        type: element.type,
+    };
+}
+exports.tableData = tableData;
+function createCell(config) {
+    if (!config.tableId || !config.rowId || !config.columnId)
+        throw new Error(TABLE_ERROR.INVALID_TABLE);
+    return util_1.ObjectUtil.mergeDeep({
+        id: (0, nanoid_1.nanoid)(16),
+        type: 'cell',
+        text: '',
+        size: {
+            width: table_constants_1.TABLE_CELL_WIDTH,
+            height: table_constants_1.TABLE_ROW_MIN_HEIGHT,
+        },
+        style: util_1.ObjectUtil.cloneDeep(TableService.DEFAULT_CELL_STYLE),
+        position: { x: 0, y: 0 },
+        colspan: 1,
+        rowspan: 1,
+    }, config);
+}
+exports.createCell = createCell;
+class TableService {
+    constructor() { }
+    static createEmptyTableElement(position, rows = 4, columns = 3) {
+        const rowElements = [];
+        const rowIds = [];
+        const columnElements = [];
+        const columnIds = [];
+        const cellElements = [];
+        const tableId = (0, nanoid_1.nanoid)(16);
+        for (let i = 0; i < rows; i++) {
+            const rowId = (0, nanoid_1.nanoid)(16);
+            const row = {
+                id: rowId,
+                tableId,
+                type: 'row',
+                size: {
+                    width: 1,
+                    height: table_constants_1.TABLE_CELL_HEIGHT,
+                },
+                style: {
+                    backgroundColor: table_constants_1.TRANSPARENT_COLOR,
+                },
+                position: { x: 0, y: 0 },
+            };
+            rowIds.push(rowId);
+            rowElements.push(row);
+        }
+        for (let j = 0; j < columns; j++) {
+            const columnId = (0, nanoid_1.nanoid)(16);
+            const column = {
+                id: columnId,
+                tableId,
+                type: 'column',
+                size: {
+                    width: table_constants_1.TABLE_CELL_WIDTH,
+                    height: 1,
+                },
+                style: {
+                    backgroundColor: table_constants_1.TRANSPARENT_COLOR,
+                },
+                position: { x: 0, y: 0 },
+            };
+            columnIds.push(columnId);
+            columnElements.push(column);
+        }
+        for (let i = 0; i < rowIds.length; i++) {
+            for (let j = 0; j < columnIds.length; j++) {
+                const cell = createCell({ rowId: rowIds[i], columnId: columnIds[j], tableId });
+                cellElements.push(cell);
+            }
+        }
+        const tableElement = {
+            type: 'table',
+            id: tableId,
+            position: {
+                x: position.x - table_constants_1.TABLE_CELL_WIDTH * 0.5,
+                y: position.y - table_constants_1.TABLE_CELL_HEIGHT * 0.5,
+            },
+            size: {
+                width: columns * table_constants_1.TABLE_CELL_WIDTH,
+                height: rows * table_constants_1.TABLE_CELL_HEIGHT,
+            },
+            style: {
+                backgroundColor: table_constants_1.TRANSPARENT_COLOR,
+                border: {
+                    width: 1,
+                    color: '#616161',
+                },
+            },
+            rowIds,
+            columnIds,
+        };
+        return [tableElement, ...rowElements, ...columnElements, ...cellElements];
+    }
+    static addColumn(tableElement, childElements, index, optionalWidth) {
+        const prevColumnId = tableElement.columnIds[Math.max(0, index - 1)];
+        const prevColumnCells = TableService.getCellsAtColumn(prevColumnId, tableElement, childElements);
+        const width = optionalWidth != null ? optionalWidth : childElements.find(e => e.id === prevColumnId).size.width;
+        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements).filter(range => range.startColumn < index && index <= range.endColumn);
+        const cellsToUpdate = [];
+        if (mergedRanges.length > 0) {
+            const columnIndexes = [...new Set(mergedRanges.map(range => range.startColumn))];
+            for (const columnIndex of columnIndexes) {
+                const targetColumnId = tableElement.columnIds[columnIndex];
+                const targetCells = this.getCellsAtColumn(targetColumnId, tableElement, childElements);
+                for (const cell of targetCells) {
+                    if (cell.colspan > 1 && columnIndex + cell.colspan > index) {
+                        const cellUndo = {
+                            id: cell.id,
+                            type: cell.type,
+                            tableId: cell.tableId,
+                            colspan: cell.colspan,
+                            size: Object.assign({}, cell.size),
+                        };
+                        cell.colspan = cell.colspan + 1;
+                        cell.size.width = cell.size.width + width;
+                        cell.size.height = TableService.getCellSize(cell).height;
+                        cellsToUpdate.push({
+                            change: {
+                                id: cell.id,
+                                type: cell.type,
+                                tableId: cell.tableId,
+                                colspan: cell.colspan,
+                                size: cell.size,
+                            },
+                            undo: cellUndo,
+                        });
+                    }
+                }
+            }
+        }
+        const columnId = (0, nanoid_1.nanoid)(16);
+        const column = {
+            id: columnId,
+            tableId: tableElement.id,
+            type: 'column',
+            size: {
+                width,
+                height: 1,
+            },
+            position: { x: 0, y: 0 },
+        };
+        const tableUndo = {
+            id: tableElement.id,
+            size: Object.assign({}, tableElement.size),
+            type: tableElement.type,
+            tableId: tableElement.id,
+            columnIds: [...tableElement.columnIds],
+        };
+        tableElement.size.width = tableElement.size.width + width;
+        tableElement.columnIds.splice(index, 0, columnId);
+        const cellElements = [];
+        for (let i = 0; i < tableElement.rowIds.length; i++) {
+            const prevCell = prevColumnCells[i];
+            const cell = createCell({
+                rowId: tableElement.rowIds[i],
+                columnId,
+                tableId: tableElement.id,
+                size: {
+                    width: width,
+                    height: table_constants_1.TABLE_ROW_MIN_HEIGHT,
+                },
+                style: prevCell.style,
+            });
+            cellElements.push(cell);
+        }
+        return {
+            elementsToCreate: [column, ...cellElements],
+            elementsToUpdate: [
+                {
+                    change: {
+                        id: tableElement.id,
+                        size: tableElement.size,
+                        type: tableElement.type,
+                        tableId: tableElement.id,
+                        columnIds: [...tableElement.columnIds],
+                    },
+                    undo: tableUndo,
+                },
+                ...cellsToUpdate,
+            ],
+        };
+    }
+    static getCellsAtColumn(columnId, tableElement, childElements) {
+        return childElements
+            .filter(element => element.type === 'cell' && element.columnId === columnId)
+            .sort((a, b) => tableElement.rowIds.indexOf(a.rowId) - tableElement.rowIds.indexOf(b.rowId));
+    }
+    static getCellsAtRow(rowId, tableElement, childElements) {
+        return childElements
+            .filter(element => element.type === 'cell' && element.rowId === rowId)
+            .sort((a, b) => tableElement.columnIds.indexOf(a.columnId) - tableElement.columnIds.indexOf(b.columnId));
+    }
+    static addRow(tableElement, childElements, index, optionalHeight) {
+        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements).filter(range => range.startRow < index && index <= range.endRow);
+        const cellsToUpdate = [];
+        if (mergedRanges.length > 0) {
+            const rowIndexes = [...new Set(mergedRanges.map(range => range.startRow))];
+            for (const rowIndex of rowIndexes) {
+                const targetRowId = tableElement.rowIds[rowIndex];
+                const targetCells = this.getCellsAtRow(targetRowId, tableElement, childElements);
+                for (const cell of targetCells) {
+                    if (cell.rowspan > 1 && rowIndex + cell.rowspan > index) {
+                        const cellUndo = {
+                            id: cell.id,
+                            type: cell.type,
+                            tableId: cell.tableId,
+                            rowspan: cell.rowspan,
+                        };
+                        cell.rowspan = cell.rowspan + 1;
+                        cellsToUpdate.push({
+                            change: {
+                                id: cell.id,
+                                type: cell.type,
+                                tableId: cell.tableId,
+                                rowspan: cell.rowspan,
+                            },
+                            undo: cellUndo,
+                        });
+                    }
+                }
+            }
+        }
+        const prevRowId = tableElement.rowIds[Math.max(0, index - 1)];
+        const prevRowCells = TableService.getCellsAtRow(prevRowId, tableElement, childElements);
+        const height = optionalHeight != null ? optionalHeight : childElements.find(e => e.id === prevRowId).size.height;
+        const rowId = (0, nanoid_1.nanoid)(16);
+        const row = {
+            id: rowId,
+            tableId: tableElement.id,
+            type: 'row',
+            size: {
+                width: 1,
+                height,
+            },
+            position: { x: 0, y: 0 },
+        };
+        const tableUndo = {
+            id: tableElement.id,
+            size: Object.assign({}, tableElement.size),
+            type: tableElement.type,
+            tableId: tableElement.id,
+            rowIds: [...tableElement.rowIds],
+        };
+        tableElement.size.height = tableElement.size.height + height;
+        tableElement.rowIds.splice(index, 0, rowId);
+        const cellElements = [];
+        for (let i = 0; i < tableElement.columnIds.length; i++) {
+            const prevCell = prevRowCells[i];
+            const cell = createCell({
+                rowId,
+                columnId: tableElement.columnIds[i],
+                tableId: tableElement.id,
+                size: {
+                    width: prevCell.size.width,
+                    height: table_constants_1.TABLE_ROW_MIN_HEIGHT,
+                },
+                style: prevCell.style,
+            });
+            cellElements.push(cell);
+        }
+        return {
+            elementsToCreate: [row, ...cellElements],
+            elementsToUpdate: [
+                {
+                    change: {
+                        id: tableElement.id,
+                        size: tableElement.size,
+                        type: tableElement.type,
+                        tableId: tableElement.id,
+                        rowIds: [...tableElement.rowIds],
+                    },
+                    undo: tableUndo,
+                },
+                ...cellsToUpdate,
+            ],
+        };
+    }
+    static getCellsAtRanges(tableElement, childElements, ranges) {
+        const elements = [];
+        const elementsMap = new Map();
+        for (const range of ranges) {
+            range.each((rowIndex, columnIndex) => {
+                const cell = childElements.find(e => e.type === 'cell' &&
+                    e.rowId === tableElement.rowIds[rowIndex] &&
+                    e.columnId === tableElement.columnIds[columnIndex]);
+                if (cell && !elementsMap.get(cell.id)) {
+                    elements.push(cell);
+                    elementsMap.set(cell.id, true);
+                }
+            });
+        }
+        return elements;
+    }
+    static deleteTable(tableElement, childElements) {
+        return { elementsToDelete: [tableElement, ...childElements] };
+    }
+    static deleteColumns(tableElement, childElements, columnIndexes) {
+        const columnIdsToDelete = tableElement.columnIds.filter((columnId, index) => columnIndexes.indexOf(index) !== -1);
+        if (columnIdsToDelete.length === tableElement.columnIds.length) {
+            return this.deleteTable(tableElement, childElements);
+        }
+        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements).filter(range => columnIndexes.filter(columnIndex => range.intersectsCol(columnIndex, columnIndex)).length > 0);
+        const columnsToDelete = columnIdsToDelete.map(columnId => childElements.find(e => e.type === 'column' && e.id === columnId));
+        const cellsToDelete = childElements.filter(e => e.type === 'cell' && columnIdsToDelete.indexOf(e.columnId) !== -1);
+        let deleteAllowed = true;
+        if (mergedRanges.length > 0) {
+            for (const cell of this.getCellsAtRanges(tableElement, childElements, mergedRanges)) {
+                if (!cellsToDelete.find(e => e.id === cell.id)) {
+                    deleteAllowed = false;
+                    break;
+                }
+            }
+        }
+        if (!deleteAllowed) {
+            throw new Error(TABLE_ERROR.UNMERGE_TO_DELETE_COLUMN);
+        }
+        const tableUndo = {
+            id: tableElement.id,
+            type: tableElement.type,
+            tableId: tableElement.id,
+            size: Object.assign({}, tableElement.size),
+            columnIds: [...tableElement.columnIds],
+        };
+        tableElement.columnIds = tableElement.columnIds.filter(id => columnIdsToDelete.indexOf(id) === -1);
+        tableElement.size.width =
+            tableElement.size.width - columnsToDelete.reduce((totalWidth, element) => totalWidth + element.size.width, 0);
+        return {
+            elementsToDelete: [...columnsToDelete, ...cellsToDelete],
+            elementsToUpdate: [
+                {
+                    change: {
+                        id: tableElement.id,
+                        type: tableElement.type,
+                        tableId: tableElement.id,
+                        size: Object.assign({}, tableElement.size),
+                        columnIds: [...tableElement.columnIds],
+                    },
+                    undo: tableUndo,
+                },
+            ],
+        };
+    }
+    static deleteRows(tableElement, childElements, rowIndexes) {
+        const rowIdsToDelete = tableElement.rowIds.filter((rowId, index) => rowIndexes.indexOf(index) !== -1);
+        if (rowIdsToDelete.length === tableElement.rowIds.length) {
+            return this.deleteTable(tableElement, childElements);
+        }
+        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements).filter(range => rowIndexes.filter(rowIndex => range.intersectsRow(rowIndex, rowIndex)).length > 0);
+        const rowsToDelete = rowIdsToDelete.map(rowId => childElements.find(e => e.type === 'row' && e.id === rowId));
+        const cellsToDelete = childElements.filter(e => e.type === 'cell' && rowIdsToDelete.indexOf(e.rowId) !== -1);
+        let deleteAllowed = true;
+        if (mergedRanges.length > 0) {
+            for (const cell of this.getCellsAtRanges(tableElement, childElements, mergedRanges)) {
+                if (!cellsToDelete.find(e => e.id === cell.id)) {
+                    deleteAllowed = false;
+                    break;
+                }
+            }
+        }
+        if (!deleteAllowed) {
+            throw new Error(TABLE_ERROR.UNMERGE_TO_DELETE_ROW);
+        }
+        const tableUndo = {
+            id: tableElement.id,
+            type: tableElement.type,
+            tableId: tableElement.id,
+            size: Object.assign({}, tableElement.size),
+            rowIds: [...tableElement.rowIds],
+        };
+        tableElement.rowIds = tableElement.rowIds.filter(id => rowIdsToDelete.indexOf(id) === -1);
+        tableElement.size.height =
+            tableElement.size.height - rowsToDelete.reduce((totalHeight, element) => totalHeight + element.size.height, 0);
+        return {
+            elementsToDelete: [...rowsToDelete, ...cellsToDelete],
+            elementsToUpdate: [
+                {
+                    change: {
+                        id: tableElement.id,
+                        type: tableElement.type,
+                        tableId: tableElement.id,
+                        size: Object.assign({}, tableElement.size),
+                        rowIds: [...tableElement.rowIds],
+                    },
+                    undo: tableUndo,
+                },
+            ],
+        };
+    }
+    static move(key, tableElement, childElements, from, to) {
+        const isColumn = key === 'columnIds';
+        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements);
+        const fromMergedRanges = mergedRanges.filter(range => isColumn ? range.cols > 0 && range.intersectsCol(from, from) : range.rows > 0 && range.intersectsRow(from, from));
+        const indexIncrement = from < to ? 1 : 0;
+        const toMergedRanges = mergedRanges.filter(range => isColumn
+            ? range.startColumn - indexIncrement < to && to <= range.endColumn - indexIncrement
+            : range.startRow - indexIncrement < to && to <= range.endRow - indexIncrement);
+        if (fromMergedRanges.length > 0 || toMergedRanges.length > 0) {
+            throw new Error(isColumn ? TABLE_ERROR.UMMERGE_TO_MOVE_COLUMN : TABLE_ERROR.UMMERGE_TO_MOVE_ROW);
+        }
+        const tableUndo = Object.assign(Object.assign({}, tableData(tableElement)), { [key]: [...tableElement[key]] });
+        util_2.OrderUtil.move(tableElement[key], from, to);
+        return {
+            elementsToUpdate: [
+                {
+                    change: Object.assign(Object.assign({}, tableData(tableElement)), { [key]: [...tableElement[key]] }),
+                    undo: tableUndo,
+                },
+            ],
+        };
+    }
+    static resizeRow(tableElement, childElements, rowId, height) {
+        const row = childElements.find(e => e.type === 'row' && e.id === rowId);
+        const rowUndo = Object.assign(Object.assign({}, tableData(row)), { size: Object.assign({}, row.size) });
+        const tableUndo = Object.assign(Object.assign({}, tableData(tableElement)), { size: Object.assign({}, tableElement.size) });
+        row.size.height = height;
+        tableElement.size.height = childElements
+            .filter(e => e.type === 'row')
+            .reduce((acc, row) => acc + row.size.height, 0);
+        return {
+            elementsToUpdate: [
+                {
+                    change: Object.assign(Object.assign({}, tableData(tableElement)), { size: tableElement.size }),
+                    undo: tableUndo,
+                },
+                {
+                    change: Object.assign(Object.assign({}, tableData(row)), { size: row.size }),
+                    undo: rowUndo,
+                },
+            ],
+        };
+    }
+    static resizeColumn(tableElement, childElements, columnId, width) {
+        const column = childElements.find(e => e.type === 'column' && e.id === columnId);
+        const columnUndo = Object.assign(Object.assign({}, tableData(column)), { size: Object.assign({}, column.size) });
+        const tableUndo = Object.assign(Object.assign({}, tableData(tableElement)), { size: Object.assign({}, tableElement.size) });
+        column.size.width = width;
+        tableElement.size.width = childElements
+            .filter(e => e.type === 'column')
+            .reduce((acc, column) => acc + column.size.width, 0);
+        return {
+            elementsToUpdate: [
+                {
+                    change: Object.assign(Object.assign({}, tableData(tableElement)), { size: tableElement.size }),
+                    undo: tableUndo,
+                },
+                {
+                    change: Object.assign(Object.assign({}, tableData(column)), { size: column.size }),
+                    undo: columnUndo,
+                },
+            ],
+        };
+    }
+    static getColumns(tableElement, childElements) {
+        const columns = [];
+        for (const columnId of tableElement.columnIds) {
+            const column = childElements.find(e => e.type === 'column' && e.id === columnId);
+            if (!column)
+                throw new Error(TABLE_ERROR.INVALID_TABLE);
+            columns.push(column);
+        }
+        return columns;
+    }
+    static getColumnsWidth(tableElement, childElements, startIndex, endIndex) {
+        const columns = this.getColumns(tableElement, childElements);
+        let width = 0;
+        for (let i = startIndex; i <= endIndex; i++) {
+            const column = columns[i];
+            if (column) {
+                width = width + column.size.width;
+            }
+        }
+        return width;
+    }
+    static getRows(tableElement, childElements) {
+        const rows = [];
+        for (const rowId of tableElement.rowIds) {
+            const row = childElements.find(e => e.type === 'row' && e.id === rowId);
+            if (!row)
+                throw new Error(TABLE_ERROR.INVALID_TABLE);
+            rows.push(row);
+        }
+        return rows;
+    }
+    static getRowsHeight(tableElement, childElements, startIndex, endIndex, skipIndex) {
+        const rows = this.getRows(tableElement, childElements);
+        let height = 0;
+        for (let i = startIndex; i <= endIndex; i++) {
+            const row = rows[i];
+            if (row && (skipIndex == null || skipIndex !== i)) {
+                height = height + row.size.height;
+            }
+        }
+        return height;
+    }
+    static getCellMinHeight(cell, tableElement, childElements) {
+        let height = cell.size.height;
+        const rowIndex = tableElement.rowIds.indexOf(cell.rowId);
+        const columnIndex = tableElement.columnIds.indexOf(cell.columnId);
+        if (rowIndex < 0 || columnIndex < 0)
+            throw new Error(TABLE_ERROR.INVALID_TABLE);
+        const cellRange = new table_range_1.TableRange(rowIndex, rowIndex, columnIndex, columnIndex);
+        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements);
+        const mergedRange = mergedRanges.find(range => cellRange.within(range));
+        if (mergedRange) {
+            const mergedRangeStart = mergedRange && cellRange.equals(mergedRange.start());
+            const mergedCell = mergedRangeStart
+                ? cell
+                : childElements.find(e => e.type === 'cell' &&
+                    e.rowId === tableElement.rowIds[mergedRange.startRow] &&
+                    e.columnId === tableElement.columnIds[mergedRange.startColumn]);
+            height =
+                mergedCell.size.height -
+                    TableService.getRowsHeight(tableElement, childElements, mergedRange.startRow, mergedRange.endRow, rowIndex);
+        }
+        return height;
+    }
+    static autoFitRows(tableElement, childElements, columnId) {
+        var _a;
+        const elementsToUpdate = [];
+        const columnIndex = tableElement.columnIds.indexOf(columnId);
+        const column = childElements.find(e => e.type === 'column' && e.id === columnId);
+        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements);
+        for (const [rowIndex, rowId] of tableElement.rowIds.entries()) {
+            const row = childElements.find(e => e.type === 'row' && e.id === rowId);
+            const cell = childElements.find(e => e.type === 'cell' && e.rowId === rowId && e.columnId === columnId);
+            if (!row || !cell)
+                continue;
+            const cellUndo = util_1.ObjectUtil.cloneDeep(cell);
+            const cellRange = new table_range_1.TableRange(rowIndex, rowIndex, columnIndex, columnIndex);
+            const mergedRange = mergedRanges.find(range => cellRange.within(range));
+            const mergedRangeStart = mergedRange && cellRange.equals(mergedRange.start());
+            const mergedRangeOther = mergedRange && !cellRange.equals(mergedRange.start());
+            if (mergedRangeOther) {
+                const mergedCell = childElements.find(e => e.type === 'cell' &&
+                    e.rowId === tableElement.rowIds[mergedRange.startRow] &&
+                    e.columnId === tableElement.columnIds[mergedRange.startColumn]);
+                if (rowIndex === mergedRange.endRow && columnIndex !== mergedRange.startColumn) {
+                    const mergedCellUndo = util_1.ObjectUtil.cloneDeep(mergedCell);
+                    mergedCell.size.width = TableService.getColumnsWidth(tableElement, childElements, mergedRange.startColumn, mergedRange.endColumn);
+                    const adjustedSize = TableService.getCellSize(mergedCell);
+                    mergedCell.size.height = adjustedSize.height;
+                    elementsToUpdate.push({
+                        change: mergedCell,
+                        undo: mergedCellUndo,
+                    });
+                }
+            }
+            cell.size.width = mergedRangeStart
+                ? TableService.getColumnsWidth(tableElement, childElements, mergedRange.startColumn, mergedRange.endColumn)
+                : column.size.width;
+            const adjustedSize = TableService.getCellSize(cell);
+            cell.size.height = adjustedSize.height;
+            elementsToUpdate.push({
+                change: cell,
+                undo: cellUndo,
+            });
+            if (rowIndex === ((_a = mergedRange === null || mergedRange === void 0 ? void 0 : mergedRange.endRow) !== null && _a !== void 0 ? _a : rowIndex)) {
+                const cellHeight = TableService.getCellMinHeight(cell, tableElement, childElements);
+                if (cellHeight > row.size.height) {
+                    elementsToUpdate.push(TableService.resizeRow(tableElement, childElements, rowId, cellHeight).elementsToUpdate[1]);
+                }
+            }
+        }
+        return { elementsToUpdate };
+    }
+    static clearCell(element) {
+        element.text = '';
+        element.size.height = table_constants_1.TABLE_ROW_MIN_HEIGHT;
+    }
+    static getCellSize(element, text) {
+        var _a, _b, _c, _d, _e, _f;
+        const fontFamily = `${(_c = (_b = (_a = element.style) === null || _a === void 0 ? void 0 : _a.font) === null || _b === void 0 ? void 0 : _b.family) !== null && _c !== void 0 ? _c : table_constants_1.DEFAULT_TEXT_FONT_FAMILY}`;
+        const fontSize = `${(_f = (_e = (_d = element.style) === null || _d === void 0 ? void 0 : _d.font) === null || _e === void 0 ? void 0 : _e.size) !== null && _f !== void 0 ? _f : table_constants_1.DEFAULT_TEXT_FONT_SIZE}pt`;
+        const fixedWidth = `${element.size.width - table_constants_1.TABLE_TEXT_PADDING * 2}px`;
+        const size = this.getSize(text !== null && text !== void 0 ? text : element.text, `width: ${fixedWidth}; height: auto; font-family: ${fontFamily}; font-size: ${fontSize};`);
+        return { height: Math.max(size.height + table_constants_1.TABLE_TEXT_PADDING * 2, table_constants_1.TABLE_ROW_MIN_HEIGHT), width: size.width };
+    }
+    static getSize(text, style) {
+        if (!document)
+            throw new Error('No document found.');
+        let div = document.createElement('div');
+        div.innerHTML = text;
+        div.setAttribute('class', 'text-calc');
+        div.setAttribute('style', style);
+        document.body.appendChild(div);
+        const width = div.clientWidth;
+        const height = div.clientHeight;
+        document.body.removeChild(div);
+        div = null;
+        return { width, height };
+    }
+}
+exports.TableService = TableService;
+TableService.DEFAULT_CELL_STYLE = {
+    font: {
+        size: table_constants_1.DEFAULT_TEXT_FONT_SIZE,
+        family: table_constants_1.DEFAULT_TEXT_FONT_FAMILY,
+    },
+    text: {
+        align: table_constants_1.TEXT_ALIGN,
+        valign: table_constants_1.TEXT_VALIGN,
+    },
+    backgroundColor: table_constants_1.TRANSPARENT_COLOR,
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@contrail/document-table",
+  "version": "1.0.1",
+  "description": "Library for document tables",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "tslint -p tsconfig.json",
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^29.5.2",
+    "jest": "^29.5.0",
+    "nanoid": "^3.2.0",
+    "prettier": "^1.19.1",
+    "ts-jest": "^29.1.1",
+    "tslint": "^5.11.0",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.0.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".spec.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  },
+  "dependencies": {
+    "@contrail/actions": "^1.0.14",
+    "@contrail/documents": "^1.0.108",
+    "@contrail/types": "^3.0.71",
+    "@contrail/util": "^1.0.65",
+    "reflect-metadata": "^0.1.13"
+  }
+}