@contrail/document-table 1.0.5-alpha.1 → 1.0.6

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

@@ -11,7 +11,7 @@ class TableCopyService {
     static copy(tableElement, childElements) {
         const copiedChildElementIds = new Map();
         const childElementsMap = new Map();
-        childElements.forEach(element => {
+        childElements.forEach((element) => {
             childElementsMap.set(element.id, element);
         });
         const rowIds = [];
@@ -55,16 +55,16 @@ class TableCopyService {
             columnIds.push(newElement.id);
             newChildElements.push(newElement);
         }
-        const cellElements = childElements.filter(e => e.type === 'cell');
+        const cellElements = childElements.filter((e) => e.type === 'cell');
         if (cellElements.length < tableElement.rowIds.length * tableElement.columnIds.length) {
             for (let i = 0; i < tableElement.rowIds.length; i++) {
                 for (let j = 0; j < tableElement.columnIds.length; j++) {
                     const rowId = tableElement.rowIds[i];
                     const columnId = tableElement.columnIds[j];
-                    const cellElement = cellElements.find(e => e.type === 'cell' && e.rowId === rowId && e.columnId === columnId);
+                    const cellElement = cellElements.find((e) => e.type === 'cell' && e.rowId === rowId && e.columnId === columnId);
                     if (!cellElement) {
-                        const row = childElements.find(e => e.id === rowId);
-                        const column = childElements.find(e => e.id === columnId);
+                        const row = childElements.find((e) => e.id === rowId);
+                        const column = childElements.find((e) => e.id === columnId);
                         cellElements.push((0, table_service_1.createCell)({
                             rowId,
                             columnId,
@@ -98,6 +98,7 @@ class TableCopyService {
         }
         newTableElement.rowIds = rowIds;
         newTableElement.columnIds = columnIds;
+        console.log(newChildElements);
         return [newTableElement, ...newChildElements];
     }
     static createTableFromCells(element, rows, columns, cells) {
@@ -110,7 +111,7 @@ class TableCopyService {
         const tableId = (0, nanoid_1.nanoid)(16);
         let width = 0, height = 0;
         let startRow, endRow, startColumn, endColumn;
-        cells.forEach(cell => {
+        cells.forEach((cell) => {
             const rowIndex = element.rowIds.indexOf(cell.rowId);
             const columnIndex = element.columnIds.indexOf(cell.columnId);
             const isNotSet = startRow == undefined;
@@ -124,8 +125,8 @@ class TableCopyService {
                 endColumn = columnIndex;
             existingCellsMap.set(`${rowIndex}_${columnIndex}`, cell);
         });
-        const skipRows = Array.from({ length: endRow - startRow + 1 }, (value, index) => startRow + index).filter(i => !Array.from(existingCellsMap.keys()).find(v => v.startsWith(`${i}_`)));
-        const skipColumns = Array.from({ length: endColumn - startColumn + 1 }, (value, index) => startColumn + index).filter(j => !Array.from(existingCellsMap.keys()).find(v => v.endsWith(`_${j}`)));
+        const skipRows = Array.from({ length: endRow - startRow + 1 }, (value, index) => startRow + index).filter((i) => !Array.from(existingCellsMap.keys()).find((v) => v.startsWith(`${i}_`)));
+        const skipColumns = Array.from({ length: endColumn - startColumn + 1 }, (value, index) => startColumn + index).filter((j) => !Array.from(existingCellsMap.keys()).find((v) => v.endsWith(`_${j}`)));
         for (let i = startRow; i <= endRow; i++) {
             if (skipRows.indexOf(i) !== -1)
                 continue;
@@ -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);
                 }
@@ -275,8 +277,7 @@ class TableCopyService {
         var _a, _b, _c, _d, _e, _f;
         const fontFamily = `${(_c = (_b = (_a = cellElement.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 = cellElement.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 size = table_service_1.TableService.getSize(cellElement.text, `width: ${cellElement.size.width -
-            table_constants_1.TABLE_TEXT_PADDING * 2}px; height: auto; font-family: ${fontFamily}; font-size: ${fontSize};`);
+        const size = table_service_1.TableService.getSize(cellElement.text, `width: ${cellElement.size.width - table_constants_1.TABLE_TEXT_PADDING * 2}px; height: auto; font-family: ${fontFamily}; font-size: ${fontSize};`);
         const documentElement = {
             isTextTool: true,
             text: cellElement.text,

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");
@@ -33,7 +34,7 @@ class TableMergeService {
                 const rowId = tableElement.rowIds[i];
                 for (let j = columnIndex; j < columnIndex + ((_b = cell.colspan) !== null && _b !== void 0 ? _b : 1); j++) {
                     const columnId = tableElement.columnIds[j];
-                    const mergedCell = childElements.find(e => e.type === 'cell' && e.columnId === columnId && e.rowId === rowId);
+                    const mergedCell = childElements.find((e) => e.type === 'cell' && e.columnId === columnId && e.rowId === rowId);
                     if (mergedCell) {
                         mergedCells.push(mergedCell);
                     }
@@ -45,7 +46,7 @@ class TableMergeService {
     static isValidRangeToMerge(tableElement, childElements, tableRange) {
         if (tableRange.singular())
             return false;
-        const mergedRanges = TableMergeService.getMergedRanges(tableElement, childElements).filter(range => range.intersects(tableRange) && !range.within(tableRange));
+        const mergedRanges = TableMergeService.getMergedRanges(tableElement, childElements).filter((range) => range.intersects(tableRange) && !range.within(tableRange));
         return mergedRanges.length === 0;
     }
     static merge(tableElement, childElements, tableRange) {
@@ -59,30 +60,49 @@ class TableMergeService {
         tableRange.each((rowIndex, columnIndex) => {
             const rowId = tableElement.rowIds[rowIndex];
             const columnId = tableElement.columnIds[columnIndex];
-            const element = childElements.find(e => e.type === 'cell' && e.columnId === columnId && e.rowId === rowId);
+            const element = childElements.find((e) => e.type === 'cell' && e.columnId === columnId && e.rowId === rowId);
             if (element) {
                 const elementUndo = util_1.ObjectUtil.cloneDeep(element);
                 element.colspan = 1;
                 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 });
@@ -96,27 +116,42 @@ class TableMergeService {
     }
     static unmerge(tableElement, childElements, tableRange) {
         const mergedRanges = TableMergeService.getMergedRanges(tableElement, childElements);
-        if (!mergedRanges.find(range => range.equals(tableRange)))
+        if (!mergedRanges.find((range) => range.equals(tableRange)))
             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];
             const columnId = tableElement.columnIds[columnIndex];
-            const element = childElements.find(e => e.type === 'cell' && e.columnId === columnId && e.rowId === rowId);
-            const column = childElements.find(e => e.type === 'column' && e.id === columnId);
-            const row = childElements.find(e => e.type === 'row' && e.id === rowId);
+            const element = childElements.find((e) => e.type === 'cell' && e.columnId === columnId && e.rowId === rowId);
+            const column = childElements.find((e) => e.type === 'column' && e.id === columnId);
+            const row = childElements.find((e) => e.type === 'row' && e.id === rowId);
             if (element && column && row) {
                 const elementUndo = util_1.ObjectUtil.cloneDeep(element);
                 element.colspan = 1;
                 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,17 @@ 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];
+            elementsToUpdate.push(updatedRow);
+        }
         return {
             elementsToUpdate: [
                 {

package/lib/table-paste.service.js

@@ -13,23 +13,23 @@ class TablePasteService {
     }
     static pasteRowsAndColumns(tableElement, childElements, elementsToPaste, targetRow, targetColumn) {
         var _a, _b, _c;
-        const tableToPaste = elementsToPaste.find(e => e.type === 'table');
-        const rowsToPaste = elementsToPaste.filter(e => e.type === 'row');
-        const columnsToPaste = elementsToPaste.filter(e => e.type === 'column');
-        const cellsToPaste = elementsToPaste.filter(e => e.type === 'cell');
+        const tableToPaste = elementsToPaste.find((e) => e.type === 'table');
+        const rowsToPaste = elementsToPaste.filter((e) => e.type === 'row');
+        const columnsToPaste = elementsToPaste.filter((e) => e.type === 'column');
+        const cellsToPaste = elementsToPaste.filter((e) => e.type === 'cell');
         const startRow = targetRow;
         const endRow = startRow + tableToPaste.rowIds.length - 1;
         const startColumn = targetColumn;
         const endColumn = startColumn + tableToPaste.columnIds.length - 1;
-        const existingCells = childElements.filter(e => e.type === 'cell');
+        const existingCells = childElements.filter((e) => e.type === 'cell');
         const elementsToCreate = [];
         const elementsToUpdate = [];
         let existingMergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements);
         for (let rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
             const rowToPaste = rowsToPaste[rowIndex - targetRow];
             let existingRowId = tableElement.rowIds[rowIndex];
-            let existingRow = childElements.find(e => e.type === 'row' && e.id === existingRowId) ||
-                elementsToCreate.find(e => e.type === 'row' && e.id === existingRowId);
+            let existingRow = childElements.find((e) => e.type === 'row' && e.id === existingRowId) ||
+                elementsToCreate.find((e) => e.type === 'row' && e.id === existingRowId);
             this.log('current row', rowIndex, existingRowId, existingRow);
             if (!existingRowId) {
                 const [newRow, ...newRowCells] = (_a = table_service_1.TableService.addRow(tableElement, [...existingCells, ...elementsToCreate], rowIndex, rowToPaste.size.height)) === null || _a === void 0 ? void 0 : _a.elementsToCreate;
@@ -46,8 +46,8 @@ class TablePasteService {
             for (let columnIndex = startColumn; columnIndex <= endColumn; columnIndex++) {
                 const columnToPaste = columnsToPaste[columnIndex - targetColumn];
                 let existingColumnId = tableElement.columnIds[columnIndex];
-                let existingColumn = childElements.find(e => e.type === 'column' && e.id === existingColumnId) ||
-                    elementsToCreate.find(e => e.type === 'column' && e.id === existingColumnId);
+                let existingColumn = childElements.find((e) => e.type === 'column' && e.id === existingColumnId) ||
+                    elementsToCreate.find((e) => e.type === 'column' && e.id === existingColumnId);
                 this.log('current column', columnIndex, existingColumnId, existingColumn);
                 if (!tableElement.columnIds[columnIndex]) {
                     const [newColumn, ...newColumnCells] = (_b = table_service_1.TableService.addColumn(tableElement, [...existingCells, ...elementsToCreate], columnIndex, columnToPaste.size.width)) === null || _b === void 0 ? void 0 : _b.elementsToCreate;
@@ -58,22 +58,21 @@ class TablePasteService {
                 }
                 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 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);
                 }
-                const cellToPaste = cellsToPaste.find(e => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
+                const cellToPaste = cellsToPaste.find((e) => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
                 if (!cellToPaste)
                     continue;
                 const cellRange = new table_range_1.TableRange(rowIndex, rowIndex, columnIndex, columnIndex);
-                const mergedRange = existingMergedRanges.find(range => range.intersects(cellRange));
+                const mergedRange = existingMergedRanges.find((range) => range.intersects(cellRange));
                 const mergedRangeOther = mergedRange && !cellRange.equals(mergedRange.start());
                 if (mergedRange) {
-                    existingMergedRanges = existingMergedRanges.filter(r => !r.equals(mergedRange));
+                    existingMergedRanges = existingMergedRanges.filter((r) => !r.equals(mergedRange));
                 }
                 if (mergedRangeOther) {
                     const [updatedTable, ...unmergedCellAndRow] = (_c = table_merge_service_1.TableMergeService.unmerge(tableElement, childElements, mergedRange)) === null || _c === void 0 ? void 0 : _c.elementsToUpdate;
@@ -86,30 +85,33 @@ class TablePasteService {
         return { elementsToCreate, elementsToUpdate };
     }
     static pasteTableCells(tableElement, childElements, elementsToPaste, targetRow, targetColumn) {
-        const tableToPaste = elementsToPaste.find(e => e.type === 'table');
-        const rowsToPaste = elementsToPaste.filter(e => e.type === 'row');
-        const columnsToPaste = elementsToPaste.filter(e => e.type === 'column');
-        const cellsToPaste = elementsToPaste.filter(e => e.type === 'cell');
+        const tableToPaste = elementsToPaste.find((e) => e.type === 'table');
+        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;
         const endColumn = startColumn + tableToPaste.columnIds.length - 1;
-        const existingCells = childElements.filter(e => e.type === 'cell');
+        const existingCells = childElements.filter((e) => e.type === 'cell');
         const tableUndo = util_1.ObjectUtil.cloneDeep(tableElement);
         const { elementsToUpdate, elementsToCreate } = TablePasteService.pasteRowsAndColumns(tableElement, childElements, elementsToPaste, targetRow, targetColumn);
         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];
-                const existingColumn = childElements.find(e => e.type === 'column' && e.id === existingColumnId) ||
-                    elementsToCreate.find(e => e.type === 'column' && e.id === existingColumnId);
-                const cellToPaste = cellsToPaste.find(e => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
+                const existingColumn = childElements.find((e) => e.type === 'column' && e.id === existingColumnId) ||
+                    elementsToCreate.find((e) => e.type === 'column' && e.id === existingColumnId);
+                const cellToPaste = cellsToPaste.find((e) => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
                 if (!cellToPaste)
                     continue;
-                const createdCell = elementsToCreate.find(e => e.type === 'cell' && e.rowId === existingRowId && e.columnId === existingColumnId);
-                const existingCell = existingCells.find(e => e.rowId === existingRowId && e.columnId === existingColumnId);
+                const createdCell = elementsToCreate.find((e) => e.type === 'cell' && e.rowId === existingRowId && e.columnId === existingColumnId);
+                const existingCell = existingCells.find((e) => e.rowId === existingRowId && e.columnId === existingColumnId);
                 const cell = createdCell !== null && createdCell !== void 0 ? createdCell : existingCell;
                 const cellUndo = util_1.ObjectUtil.cloneDeep(cell);
                 this.log('cell to paste', cellToPaste);
@@ -118,11 +120,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,56 @@
+"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) {
+                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 {
+                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

@@ -120,11 +120,11 @@ class TableService {
     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 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))];
+            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);
@@ -208,19 +208,19 @@ class TableService {
     }
     static getCellsAtColumn(columnId, tableElement, childElements) {
         return childElements
-            .filter(element => element.type === 'cell' && element.columnId === columnId)
+            .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)
+            .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 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))];
+            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);
@@ -248,7 +248,7 @@ class TableService {
         }
         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 height = optionalHeight != null ? optionalHeight : childElements.find((e) => e.id === prevRowId).size.height;
         const rowId = (0, nanoid_1.nanoid)(16);
         const row = {
             id: rowId,
@@ -306,7 +306,7 @@ class TableService {
         const elementsMap = new Map();
         for (const range of ranges) {
             range.each((rowIndex, columnIndex) => {
-                const cell = childElements.find(e => e.type === 'cell' &&
+                const cell = childElements.find((e) => e.type === 'cell' &&
                     e.rowId === tableElement.rowIds[rowIndex] &&
                     e.columnId === tableElement.columnIds[columnIndex]);
                 if (cell && !elementsMap.get(cell.id)) {
@@ -325,13 +325,13 @@ class TableService {
         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);
+        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)) {
+                if (!cellsToDelete.find((e) => e.id === cell.id)) {
                     deleteAllowed = false;
                     break;
                 }
@@ -347,7 +347,7 @@ class TableService {
             size: Object.assign({}, tableElement.size),
             columnIds: [...tableElement.columnIds],
         };
-        tableElement.columnIds = tableElement.columnIds.filter(id => columnIdsToDelete.indexOf(id) === -1);
+        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 {
@@ -371,13 +371,13 @@ class TableService {
         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);
+        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)) {
+                if (!cellsToDelete.find((e) => e.id === cell.id)) {
                     deleteAllowed = false;
                     break;
                 }
@@ -393,7 +393,7 @@ class TableService {
             size: Object.assign({}, tableElement.size),
             rowIds: [...tableElement.rowIds],
         };
-        tableElement.rowIds = tableElement.rowIds.filter(id => rowIdsToDelete.indexOf(id) === -1);
+        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 {
@@ -415,9 +415,9 @@ class TableService {
     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 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
+        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) {
@@ -435,12 +435,12 @@ class TableService {
         };
     }
     static resizeRow(tableElement, childElements, rowId, height) {
-        const row = childElements.find(e => e.type === 'row' && e.id === rowId);
+        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')
+            .filter((e) => e.type === 'row')
             .reduce((acc, row) => acc + row.size.height, 0);
         return {
             elementsToUpdate: [
@@ -456,12 +456,12 @@ class TableService {
         };
     }
     static resizeColumn(tableElement, childElements, columnId, width) {
-        const column = childElements.find(e => e.type === 'column' && e.id === columnId);
+        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')
+            .filter((e) => e.type === 'column')
             .reduce((acc, column) => acc + column.size.width, 0);
         return {
             elementsToUpdate: [
@@ -479,19 +479,19 @@ class TableService {
     static getColumns(tableElement, childElements) {
         const columns = [];
         for (const columnId of tableElement.columnIds) {
-            const column = childElements.find(e => e.type === 'column' && e.id === columnId);
+            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) {
+    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;
             }
         }
@@ -500,7 +500,7 @@ class TableService {
     static getRows(tableElement, childElements) {
         const rows = [];
         for (const rowId of tableElement.rowIds) {
-            const row = childElements.find(e => e.type === 'row' && e.id === rowId);
+            const row = childElements.find((e) => e.type === 'row' && e.id === rowId);
             if (!row)
                 throw new Error(TABLE_ERROR.INVALID_TABLE);
             rows.push(row);
@@ -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);
@@ -526,12 +528,12 @@ class TableService {
             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));
+        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' &&
+                : childElements.find((e) => e.type === 'cell' &&
                     e.rowId === tableElement.rowIds[mergedRange.startRow] &&
                     e.columnId === tableElement.columnIds[mergedRange.startColumn]);
             height =
@@ -540,24 +542,48 @@ 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 = [];
         const columnIndex = tableElement.columnIds.indexOf(columnId);
-        const column = childElements.find(e => e.type === 'column' && e.id === 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)
+            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 || 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 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' &&
+                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) {
@@ -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 };
     }
@@ -616,20 +695,26 @@ class TableService {
         return { width, height };
     }
     static getTableChildElements(tableId, elements) {
-        return elements.filter(e => e.tableId === tableId && ['cell', 'column', 'row'].indexOf(e.type) !== -1);
+        return elements.filter((e) => e.tableId === tableId && ['cell', 'column', 'row'].indexOf(e.type) !== -1);
     }
     static updateCellText(tableElement, childElements, rowIndex, columnIndex, text) {
         const rowId = tableElement.rowIds[rowIndex];
         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 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-alpha.1",
+  "version": "1.0.6",
   "description": "Library for document tables",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -38,10 +38,10 @@
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@contrail/actions": "^1.0.17-alpha.2",
-    "@contrail/documents": "^1.2.9-alpha.0",
-    "@contrail/types": "^3.1.2-alpha.1",
-    "@contrail/util": "^1.1.17-alpha.2",
+    "@contrail/actions": "^1.0.17",
+    "@contrail/documents": "^1.3.2",
+    "@contrail/types": "^3.1.3",
+    "@contrail/util": "^1.1.18",
     "reflect-metadata": "^0.1.13"
   }
 }