@contrail/document-table 1.0.5 → 1.0.12

package/lib/index.d.ts

@@ -3,5 +3,6 @@ export * from './table-constants';
 export * from './table-copy.service';
 export * from './table-merge.service';
 export * from './table-paste.service';
+export * from './table-rotate.service';
 export * from './table.service';
 export * from './table-range';

package/lib/index.js

@@ -19,5 +19,6 @@ __exportStar(require("./table-constants"), exports);
 __exportStar(require("./table-copy.service"), exports);
 __exportStar(require("./table-merge.service"), exports);
 __exportStar(require("./table-paste.service"), exports);
+__exportStar(require("./table-rotate.service"), exports);
 __exportStar(require("./table.service"), exports);
 __exportStar(require("./table-range"), exports);

package/lib/table-copy.service.js

@@ -98,6 +98,7 @@ class TableCopyService {
         }
         newTableElement.rowIds = rowIds;
         newTableElement.columnIds = columnIds;
+        console.log(newChildElements);
         return [newTableElement, ...newChildElements];
     }
     static createTableFromCells(element, rows, columns, cells) {
@@ -189,6 +190,7 @@ class TableCopyService {
                         },
                         style: util_1.ObjectUtil.cloneDeep(cell.style),
                         position: { x: 0, y: 0 },
+                        rotate: Object.assign({}, cell.rotate),
                     });
                     cellElements.push(element);
                 }

package/lib/table-merge.service.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableMergeService = void 0;
+const documents_1 = require("@contrail/documents");
 const util_1 = require("@contrail/util");
 const table_service_1 = require("./table.service");
 const table_range_1 = require("./table-range");
@@ -66,23 +67,42 @@ class TableMergeService {
                 element.rowspan = 1;
                 if (tableRange.isStart(rowIndex, columnIndex)) {
                     firstCell = element;
-                    let width = 0;
-                    tableRange.eachColumn((columnIndex) => {
-                        const columnId = tableElement.columnIds[columnIndex];
-                        const column = childElements.find((e) => e.type === 'column' && e.id === columnId);
-                        width = width + column.size.width;
-                    });
-                    if (colspan > 1) {
-                        element.colspan = colspan;
+                    if (table_service_1.TableService.isVerticalCell(element)) {
+                        let height = 0;
+                        tableRange.eachRow((rowIndex) => {
+                            const rowId = tableElement.rowIds[rowIndex];
+                            const row = childElements.find((e) => e.type === 'row' && e.id === rowId);
+                            height = height + row.size.height;
+                        });
+                        if (colspan > 1) {
+                            element.colspan = colspan;
+                        }
+                        if (rowspan > 1) {
+                            element.rowspan = rowspan;
+                        }
+                        element.size.height = height;
+                        element.size.width = table_service_1.TableService.getCellSize(element).height;
                     }
-                    if (rowspan > 1) {
-                        element.rowspan = rowspan;
+                    else {
+                        let width = 0;
+                        tableRange.eachColumn((columnIndex) => {
+                            const columnId = tableElement.columnIds[columnIndex];
+                            const column = childElements.find((e) => e.type === 'column' && e.id === columnId);
+                            width = width + column.size.width;
+                        });
+                        if (colspan > 1) {
+                            element.colspan = colspan;
+                        }
+                        if (rowspan > 1) {
+                            element.rowspan = rowspan;
+                        }
+                        element.size.width = width;
+                        element.size.height = table_service_1.TableService.getCellSize(element).height;
                     }
-                    element.size.width = width;
-                    element.size.height = table_service_1.TableService.getCellSize(element).height;
                 }
                 else {
                     element.style = util_1.ObjectUtil.mergeDeep(util_1.ObjectUtil.cloneDeep(table_service_1.TableService.DEFAULT_CELL_STYLE), firstCell.style);
+                    element.rotate = Object.assign({}, firstCell.rotate);
                     table_service_1.TableService.clearCell(element);
                 }
                 elementsToUpdate.push({ change: element, undo: elementUndo });
@@ -100,6 +120,8 @@ class TableMergeService {
             throw new Error(table_service_1.TABLE_ERROR.INVALID_RANGE_TO_UNMERGE);
         const tableUndo = Object.assign(Object.assign({}, (0, table_service_1.tableData)(tableElement)), { size: Object.assign({}, tableElement.size) });
         const elementsToUpdate = [];
+        const columnWidthsToUpdate = new Map();
+        const rowHeightsToUpdate = new Map();
         let firstCell;
         tableRange.each((rowIndex, columnIndex) => {
             const rowId = tableElement.rowIds[rowIndex];
@@ -113,10 +135,23 @@ class TableMergeService {
                 element.rowspan = 1;
                 if (tableRange.isStart(rowIndex, columnIndex)) {
                     firstCell = element;
-                    element.size.width = column.size.width;
-                    element.size.height = table_service_1.TableService.getCellSize(element).height;
-                    if (element.size.height > row.size.height) {
-                        elementsToUpdate.push(table_service_1.TableService.resizeRow(tableElement, childElements, rowId, element.size.height).elementsToUpdate[1]);
+                    if (table_service_1.TableService.isVerticalCell(element)) {
+                        element.size.height = row.size.height;
+                        element.size.width = table_service_1.TableService.getCellSize(element).height;
+                        if (element.size.width > column.size.width) {
+                            if (!columnWidthsToUpdate.has(column.id) || columnWidthsToUpdate.get(column.id) < element.size.width) {
+                                columnWidthsToUpdate.set(column.id, element.size.width);
+                            }
+                        }
+                    }
+                    else {
+                        element.size.width = column.size.width;
+                        element.size.height = table_service_1.TableService.getCellSize(element).height;
+                        if (element.size.height > row.size.height) {
+                            if (!rowHeightsToUpdate.has(row.id) || rowHeightsToUpdate.get(row.id) < element.size.height) {
+                                rowHeightsToUpdate.set(row.id, element.size.height);
+                            }
+                        }
                     }
                 }
                 else {
@@ -129,6 +164,20 @@ class TableMergeService {
                 throw new Error();
             }
         });
+        for (const [columnId, width] of columnWidthsToUpdate) {
+            const updatedColumn = table_service_1.TableService.resizeColumn(tableElement, childElements, columnId, width).elementsToUpdate[1];
+            const updatedRowAndCells = table_service_1.TableService.autoFitRows(tableElement, childElements, columnId).elementsToUpdate;
+            const uniqueUpdatedRowAndCells = (0, documents_1.uniqueElementsToUpdate)(updatedRowAndCells, elementsToUpdate);
+            elementsToUpdate.push(updatedColumn);
+            elementsToUpdate.push(...uniqueUpdatedRowAndCells);
+        }
+        for (const [rowId, height] of rowHeightsToUpdate) {
+            const updatedRow = table_service_1.TableService.resizeRow(tableElement, childElements, rowId, height).elementsToUpdate[1];
+            const updatedColumnAndCells = table_service_1.TableService.autoFitColumns(tableElement, childElements, rowId).elementsToUpdate;
+            const uniqueUpdatedColumnAndCells = (0, documents_1.uniqueElementsToUpdate)(updatedColumnAndCells, elementsToUpdate);
+            elementsToUpdate.push(updatedRow);
+            elementsToUpdate.push(...uniqueUpdatedColumnAndCells);
+        }
         return {
             elementsToUpdate: [
                 {

package/lib/table-paste.service.js

@@ -24,6 +24,8 @@ class TablePasteService {
         const existingCells = childElements.filter((e) => e.type === 'cell');
         const elementsToCreate = [];
         const elementsToUpdate = [];
+        const columnWidthsToUpdate = new Map();
+        const rowHeightsToUpdate = new Map();
         let existingMergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements);
         for (let rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
             const rowToPaste = rowsToPaste[rowIndex - targetRow];
@@ -38,10 +40,9 @@ class TablePasteService {
                 existingRow = newRow;
                 this.log('added row', rowIndex, existingRowId, existingRow);
             }
-            if (rowToPaste.size.height > existingRow.size.height) {
-                this.log('resized row', rowIndex, existingRowId, existingRow);
-                elementsToUpdate.push(table_service_1.TableService.resizeRow(tableElement, childElements, existingRowId, rowToPaste.size.height)
-                    .elementsToUpdate[1]);
+            if (rowToPaste.size.height > existingRow.size.height &&
+                (!rowHeightsToUpdate.has(existingRowId) || rowHeightsToUpdate.get(existingRowId) < rowToPaste.size.height)) {
+                rowHeightsToUpdate.set(existingRowId, rowToPaste.size.height);
             }
             for (let columnIndex = startColumn; columnIndex <= endColumn; columnIndex++) {
                 const columnToPaste = columnsToPaste[columnIndex - targetColumn];
@@ -56,14 +57,10 @@ class TablePasteService {
                     existingColumn = newColumn;
                     this.log('added column', columnIndex, existingColumnId, existingColumn);
                 }
-                if (columnToPaste.size.width > existingColumn.size.width) {
-                    const updatedColumn = table_service_1.TableService.resizeColumn(tableElement, childElements, existingColumnId, columnToPaste.size.width).elementsToUpdate[1];
-                    const updatedRowAndCells = table_service_1.TableService.autoFitRows(tableElement, childElements, existingColumnId).elementsToUpdate;
-                    const uniqueUpdatedRowAndCells = (0, documents_1.uniqueElementsToUpdate)(updatedRowAndCells, elementsToUpdate);
-                    elementsToUpdate.push(updatedColumn);
-                    elementsToUpdate.push(...uniqueUpdatedRowAndCells);
-                    this.log('resized column', columnIndex, existingColumnId, existingColumn);
-                    this.log('resized column cells and row', uniqueUpdatedRowAndCells, uniqueUpdatedRowAndCells);
+                if (columnToPaste.size.width > existingColumn.size.width &&
+                    (!columnWidthsToUpdate.has(existingColumnId) ||
+                        columnWidthsToUpdate.get(existingColumnId) < columnToPaste.size.width)) {
+                    columnWidthsToUpdate.set(existingColumnId, columnToPaste.size.width);
                 }
                 const cellToPaste = cellsToPaste.find((e) => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
                 if (!cellToPaste)
@@ -82,6 +79,20 @@ class TablePasteService {
                 }
             }
         }
+        for (const [columnId, width] of columnWidthsToUpdate) {
+            const updatedColumn = table_service_1.TableService.resizeColumn(tableElement, childElements, columnId, width).elementsToUpdate[1];
+            const updatedRowAndCells = table_service_1.TableService.autoFitRows(tableElement, childElements, columnId).elementsToUpdate;
+            const uniqueUpdatedRowAndCells = (0, documents_1.uniqueElementsToUpdate)(updatedRowAndCells, elementsToUpdate);
+            elementsToUpdate.push(updatedColumn);
+            elementsToUpdate.push(...uniqueUpdatedRowAndCells);
+        }
+        for (const [rowId, height] of rowHeightsToUpdate) {
+            const updatedRow = table_service_1.TableService.resizeRow(tableElement, childElements, rowId, height).elementsToUpdate[1];
+            const updatedColumnAndCells = table_service_1.TableService.autoFitColumns(tableElement, childElements, rowId).elementsToUpdate;
+            const uniqueUpdatedColumnAndCells = (0, documents_1.uniqueElementsToUpdate)(updatedColumnAndCells, elementsToUpdate);
+            elementsToUpdate.push(updatedRow);
+            elementsToUpdate.push(...uniqueUpdatedColumnAndCells);
+        }
         return { elementsToCreate, elementsToUpdate };
     }
     static pasteTableCells(tableElement, childElements, elementsToPaste, targetRow, targetColumn) {
@@ -89,6 +100,7 @@ class TablePasteService {
         const rowsToPaste = elementsToPaste.filter((e) => e.type === 'row');
         const columnsToPaste = elementsToPaste.filter((e) => e.type === 'column');
         const cellsToPaste = elementsToPaste.filter((e) => e.type === 'cell');
+        this.log(elementsToPaste);
         const startRow = targetRow;
         const endRow = startRow + tableToPaste.rowIds.length - 1;
         const startColumn = targetColumn;
@@ -99,6 +111,8 @@ class TablePasteService {
         for (let rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
             const rowToPaste = rowsToPaste[rowIndex - targetRow];
             const existingRowId = tableElement.rowIds[rowIndex];
+            const existingRow = childElements.find((e) => e.type === 'row' && e.id === existingRowId) ||
+                elementsToCreate.find((e) => e.type === 'row' && e.id === existingRowId);
             for (let columnIndex = startColumn; columnIndex <= endColumn; columnIndex++) {
                 const columnToPaste = columnsToPaste[columnIndex - targetColumn];
                 const existingColumnId = tableElement.columnIds[columnIndex];
@@ -117,11 +131,21 @@ class TablePasteService {
                 cell.style = util_1.ObjectUtil.mergeDeep(util_1.ObjectUtil.cloneDeep(table_service_1.TableService.DEFAULT_CELL_STYLE), util_1.ObjectUtil.cloneDeep(cellToPaste.style));
                 cell.colspan = cellToPaste.colspan > 1 ? cellToPaste.colspan : 1;
                 cell.rowspan = cellToPaste.rowspan > 1 ? cellToPaste.rowspan : 1;
+                if (cellToPaste.rotate)
+                    cell.rotate = Object.assign({}, cellToPaste.rotate);
                 const cellMergedRanged = table_merge_service_1.TableMergeService.getMergedRange(tableElement, cell);
-                cell.size.width = cellMergedRanged
-                    ? table_service_1.TableService.getColumnsWidth(tableElement, [...childElements, ...elementsToCreate], cellMergedRanged.startColumn, cellMergedRanged.endColumn)
-                    : existingColumn.size.width;
-                cell.size.height = table_service_1.TableService.getCellSize(cell).height;
+                if (table_service_1.TableService.isVerticalCell(cell)) {
+                    cell.size.height = cellMergedRanged
+                        ? table_service_1.TableService.getRowsHeight(tableElement, [...childElements, ...elementsToCreate], cellMergedRanged.startRow, cellMergedRanged.endRow)
+                        : existingRow.size.height;
+                    cell.size.width = table_service_1.TableService.getCellSize(cell).height;
+                }
+                else {
+                    cell.size.width = cellMergedRanged
+                        ? table_service_1.TableService.getColumnsWidth(tableElement, [...childElements, ...elementsToCreate], cellMergedRanged.startColumn, cellMergedRanged.endColumn)
+                        : existingColumn.size.width;
+                    cell.size.height = table_service_1.TableService.getCellSize(cell).height;
+                }
                 if (!createdCell && !elementsToUpdate.find(({ change }) => change.id === cell.id)) {
                     cellUndo.colspan = cellUndo.colspan > 1 ? cellUndo.colspan : 1;
                     cellUndo.rowspan = cellUndo.rowspan > 1 ? cellUndo.rowspan : 1;

package/lib/table-rotate.service.d.ts

@@ -0,0 +1,4 @@
+import { DocumentElement, DocumentElementChanges } from '@contrail/documents';
+export declare class TableRotateService {
+    static rotateCells(tableElement: DocumentElement, childElements: DocumentElement[], cells: DocumentElement[], angle: number): DocumentElementChanges;
+}

package/lib/table-rotate.service.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableRotateService = void 0;
+const documents_1 = require("@contrail/documents");
+const table_service_1 = require("./table.service");
+const util_1 = require("@contrail/util");
+class TableRotateService {
+    static rotateCells(tableElement, childElements, cells, angle) {
+        const elementsToUpdate = [];
+        const columnWidthsToUpdate = new Map();
+        const rowHeightsToUpdate = new Map();
+        for (const cell of cells) {
+            const row = childElements.find((e) => e.type === 'row' && e.id === cell.rowId);
+            const column = childElements.find((e) => e.type === 'column' && e.id === cell.columnId);
+            if (!row || !column)
+                continue;
+            const cellUndo = util_1.ObjectUtil.cloneDeep(cell);
+            cell.rotate = { angle };
+            if (angle === 270) {
+                cellUndo.rotate = cellUndo.rotate || { angle: 0 };
+                cell.size.height = row.size.height;
+                cell.size.width = table_service_1.TableService.getCellSize(cell).height;
+                if (cell.size.width > column.size.width) {
+                    if (!columnWidthsToUpdate.has(column.id) || columnWidthsToUpdate.get(column.id) < cell.size.width) {
+                        columnWidthsToUpdate.set(column.id, cell.size.width);
+                    }
+                }
+            }
+            else {
+                cellUndo.rotate = cellUndo.rotate || { angle: 270 };
+                cell.size.width = column.size.width;
+                cell.size.height = table_service_1.TableService.getCellSize(cell).height;
+                if (cell.size.height > row.size.height) {
+                    if (!rowHeightsToUpdate.has(row.id) || rowHeightsToUpdate.get(row.id) < cell.size.height) {
+                        rowHeightsToUpdate.set(row.id, cell.size.height);
+                    }
+                }
+            }
+            elementsToUpdate.push({ change: cell, undo: cellUndo });
+        }
+        for (const [columnId, width] of columnWidthsToUpdate) {
+            const updatedColumn = table_service_1.TableService.resizeColumn(tableElement, childElements, columnId, width).elementsToUpdate[1];
+            const updatedRowAndCells = table_service_1.TableService.autoFitRows(tableElement, childElements, columnId).elementsToUpdate;
+            const uniqueUpdatedRowAndCells = (0, documents_1.uniqueElementsToUpdate)(updatedRowAndCells, elementsToUpdate);
+            elementsToUpdate.push(updatedColumn);
+            elementsToUpdate.push(...uniqueUpdatedRowAndCells);
+        }
+        for (const [rowId, height] of rowHeightsToUpdate) {
+            const updatedRow = table_service_1.TableService.resizeRow(tableElement, childElements, rowId, height).elementsToUpdate[1];
+            const updatedColumnAndCells = table_service_1.TableService.autoFitColumns(tableElement, childElements, rowId).elementsToUpdate;
+            const uniqueUpdatedColumnAndCells = (0, documents_1.uniqueElementsToUpdate)(updatedColumnAndCells, elementsToUpdate);
+            elementsToUpdate.push(updatedRow);
+            elementsToUpdate.push(...uniqueUpdatedColumnAndCells);
+        }
+        return { elementsToUpdate };
+    }
+}
+exports.TableRotateService = TableRotateService;

package/lib/table.service.d.ts

@@ -31,14 +31,17 @@ export declare class TableService {
     static resizeRow(tableElement: DocumentElement, childElements: DocumentElement[], rowId: string, height: number): DocumentElementChanges;
     static resizeColumn(tableElement: DocumentElement, childElements: DocumentElement[], columnId: string, width: number): DocumentElementChanges;
     private static getColumns;
-    static getColumnsWidth(tableElement: DocumentElement, childElements: DocumentElement[], startIndex: number, endIndex: number): number;
+    static getColumnsWidth(tableElement: DocumentElement, childElements: DocumentElement[], startIndex: number, endIndex: number, skipIndex?: number): number;
     private static getRows;
-    private static getRowsHeight;
+    static getRowsHeight(tableElement: DocumentElement, childElements: DocumentElement[], startIndex: number, endIndex: number, skipIndex?: number): number;
     private static getCellMinHeight;
+    private static getCellMinWidth;
     static autoFitRows(tableElement: DocumentElement, childElements: DocumentElement[], columnId: string): DocumentElementChanges;
+    static autoFitColumns(tableElement: DocumentElement, childElements: DocumentElement[], rowId: string): DocumentElementChanges;
     static clearCell(element: DocumentElement): void;
     static getCellSize(element: DocumentElement, text?: string): SizeDefinition;
     static getSize(text: string, style: string): SizeDefinition;
     static getTableChildElements(tableId: string, elements: DocumentElement[]): DocumentElement[];
     static updateCellText(tableElement: DocumentElement, childElements: DocumentElement[], rowIndex: number, columnIndex: number, text: string): DocumentElementChanges;
+    static isVerticalCell(element: DocumentElement): boolean;
 }

package/lib/table.service.js

@@ -486,12 +486,12 @@ class TableService {
         }
         return columns;
     }
-    static getColumnsWidth(tableElement, childElements, startIndex, endIndex) {
+    static getColumnsWidth(tableElement, childElements, startIndex, endIndex, skipIndex) {
         const columns = this.getColumns(tableElement, childElements);
         let width = 0;
         for (let i = startIndex; i <= endIndex; i++) {
             const column = columns[i];
-            if (column) {
+            if (column && (skipIndex == null || skipIndex !== i)) {
                 width = width + column.size.width;
             }
         }
@@ -519,6 +519,8 @@ class TableService {
         return height;
     }
     static getCellMinHeight(cell, tableElement, childElements) {
+        if (TableService.isVerticalCell(cell))
+            return table_constants_1.TABLE_ROW_MIN_HEIGHT;
         let height = cell.size.height;
         const rowIndex = tableElement.rowIds.indexOf(cell.rowId);
         const columnIndex = tableElement.columnIds.indexOf(cell.columnId);
@@ -540,6 +542,30 @@ class TableService {
         }
         return height;
     }
+    static getCellMinWidth(cell, tableElement, childElements) {
+        if (!TableService.isVerticalCell(cell))
+            return table_constants_1.TABLE_COLUMN_MIN_WIDTH;
+        let width = cell.size.width;
+        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]);
+            width =
+                mergedCell.size.width -
+                    TableService.getColumnsWidth(tableElement, childElements, mergedRange.startColumn, mergedRange.endColumn, columnIndex);
+        }
+        return width;
+    }
     static autoFitRows(tableElement, childElements, columnId) {
         var _a;
         const elementsToUpdate = [];
@@ -549,7 +575,7 @@ class TableService {
         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)
+            if (!row || !cell || TableService.isVerticalCell(cell))
                 continue;
             const cellUndo = util_1.ObjectUtil.cloneDeep(cell);
             const cellRange = new table_range_1.TableRange(rowIndex, rowIndex, columnIndex, columnIndex);
@@ -589,15 +615,68 @@ class TableService {
         }
         return { elementsToUpdate };
     }
+    static autoFitColumns(tableElement, childElements, rowId) {
+        var _a;
+        const elementsToUpdate = [];
+        const rowIndex = tableElement.rowIds.indexOf(rowId);
+        const row = childElements.find((e) => e.type === 'row' && e.id === rowId);
+        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements);
+        for (const [columnIndex, columnId] of tableElement.columnIds.entries()) {
+            const column = childElements.find((e) => e.type === 'column' && e.id === columnId);
+            const cell = childElements.find((e) => e.type === 'cell' && e.rowId === rowId && e.columnId === columnId);
+            if (!column || !cell || !TableService.isVerticalCell(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 (columnIndex === mergedRange.endColumn && rowIndex !== mergedRange.startRow) {
+                    const mergedCellUndo = util_1.ObjectUtil.cloneDeep(mergedCell);
+                    mergedCell.size.height = TableService.getRowsHeight(tableElement, childElements, mergedRange.startRow, mergedRange.endRow);
+                    mergedCell.size.width = TableService.getCellSize(mergedCell).height;
+                    elementsToUpdate.push({
+                        change: mergedCell,
+                        undo: mergedCellUndo,
+                    });
+                }
+            }
+            cell.size.height = mergedRangeStart
+                ? TableService.getRowsHeight(tableElement, childElements, mergedRange.startRow, mergedRange.endRow)
+                : row.size.height;
+            cell.size.width = TableService.getCellSize(cell).height;
+            elementsToUpdate.push({
+                change: cell,
+                undo: cellUndo,
+            });
+            if (columnIndex === ((_a = mergedRange === null || mergedRange === void 0 ? void 0 : mergedRange.endColumn) !== null && _a !== void 0 ? _a : columnIndex)) {
+                const cellWidth = TableService.getCellMinWidth(cell, tableElement, childElements);
+                if (cellWidth > column.size.width) {
+                    elementsToUpdate.push(TableService.resizeColumn(tableElement, childElements, columnId, cellWidth).elementsToUpdate[1]);
+                }
+            }
+        }
+        return { elementsToUpdate };
+    }
     static clearCell(element) {
         element.text = '';
-        element.size.height = table_constants_1.TABLE_ROW_MIN_HEIGHT;
+        if (TableService.isVerticalCell(element)) {
+            element.size.width = table_constants_1.TABLE_COLUMN_MIN_WIDTH;
+        }
+        else {
+            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 width = TableService.isVerticalCell(element) ? element.size.height : element.size.width;
+        const fixedWidth = `${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 };
     }
@@ -623,13 +702,19 @@ class TableService {
         const columnId = tableElement.columnIds[columnIndex];
         const cell = childElements.find((e) => e.type === 'cell' && e.rowId === rowId && e.columnId === columnId);
         const row = childElements.find((e) => e.type === 'row' && e.id === rowId);
+        const column = childElements.find((e) => e.type === 'column' && e.id === columnId);
         if (!rowId || !columnId || !cell || !row) {
             throw new Error(TABLE_ERROR.INVALID_TABLE);
         }
         const elementsToUpdate = [];
         const cellUndo = Object.assign(Object.assign({}, tableData(cell)), { text: cell.text, size: Object.assign({}, cell.size) });
         cell.text = text;
-        cell.size.height = TableService.getCellSize(cell).height;
+        if (TableService.isVerticalCell(cell)) {
+            cell.size.width = TableService.getCellSize(cell).height;
+        }
+        else {
+            cell.size.height = TableService.getCellSize(cell).height;
+        }
         elementsToUpdate.push({
             change: Object.assign(Object.assign({}, tableData(cell)), { text: cell.text, size: cell.size }),
             undo: cellUndo,
@@ -637,10 +722,17 @@ class TableService {
         if (cell.size.height > row.size.height) {
             elementsToUpdate.push(...TableService.resizeRow(tableElement, childElements, rowId, cell.size.height).elementsToUpdate);
         }
+        if (cell.size.width > column.size.width) {
+            elementsToUpdate.push(...TableService.resizeColumn(tableElement, childElements, columnId, cell.size.width).elementsToUpdate);
+        }
         return {
             elementsToUpdate,
         };
     }
+    static isVerticalCell(element) {
+        var _a;
+        return element && element.type === 'cell' && ((_a = element.rotate) === null || _a === void 0 ? void 0 : _a.angle) === 270;
+    }
 }
 exports.TableService = TableService;
 TableService.DEFAULT_CELL_STYLE = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/document-table",
-  "version": "1.0.5",
+  "version": "1.0.12",
   "description": "Library for document tables",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@contrail/actions": "^1.0.17",
-    "@contrail/documents": "^1.3.2-alpha.0",
+    "@contrail/documents": "^1.3.2",
     "@contrail/types": "^3.1.3",
     "@contrail/util": "^1.1.18",
     "reflect-metadata": "^0.1.13"