@talrace/ngx-noder 0.0.2

package/esm2022/lib/+shared/editor/custom-components/table/components/table-cell.component.mjs

@@ -0,0 +1,95 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input, ViewChild } from '@angular/core';
+import { CellResizerParametersModel } from '../models/cell-resizer-parameters.model';
+import { MarginModel } from '../../../core/models/margin.model';
+import { ResizerSide } from '../enums/reisizer-side.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../interaction/editor.service";
+import * as i2 from "../../../execution/regulator.service";
+import * as i3 from "@angular/common";
+export class NoderTableCellComponent {
+    get session() {
+        return this.cellSession.session;
+    }
+    get renderer() {
+        return this.cellSession.renderer;
+    }
+    constructor(editorService, regulatorService) {
+        this.editorService = editorService;
+        this.regulatorService = regulatorService;
+        this.isHighlighted = false;
+        this.resizerBorder = ResizerSide;
+        this.pagesCountChangedHandler = (event) => {
+            if (this._allParagraphsHeight === event.pageHeight) {
+                return;
+            }
+            this._allParagraphsHeight = event.pageHeight;
+            const cellContentHeight = this._allParagraphsHeight;
+            this.heightChanged(this.rowIndex, this.cellIndex, cellContentHeight);
+        };
+    }
+    ngOnDestroy() {
+        this.session?.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+        this.regulatorService.removeSession(this.sessionId);
+    }
+    initialize() {
+        const marginModel = new MarginModel({
+            left: 7,
+            right: 7,
+            top: 0,
+            bottom: 0,
+            header: 0,
+            footer: 0
+        });
+        this.cellSession = this.regulatorService.addCellSession(this.table, marginModel, this, this.properties);
+        this.sessionId = this.cellSession.sessionId;
+        this.addEventListeners();
+    }
+    getCellContentHeight() {
+        this._allParagraphsHeight = this.session.pagesWrap.getAllParagraphsHeight();
+        return this._allParagraphsHeight;
+    }
+    clearSelection() {
+        this.editorService.clearSelection();
+    }
+    onStartResizing(event, border) {
+        event.stopPropagation();
+        this.startResizing(new CellResizerParametersModel(this.columnIndex, this.rowIndex, this.cellIndex, border));
+    }
+    addEventListeners() {
+        this.session.pagesWrap.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NoderTableCellComponent, deps: [{ token: i1.EditorService }, { token: i2.RegulatorService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: NoderTableCellComponent, selector: "app-noder-table-cell", inputs: { table: "table", cell: "cell", rowIndex: "rowIndex", cellIndex: "cellIndex", columnIndex: "columnIndex", width: "width", parentSessionId: "parentSessionId", heightChanged: "heightChanged", startResizing: "startResizing" }, host: { properties: { "class.highlighted": "this.isHighlighted", "attr.data-session-id": "this.sessionId" } }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, static: true }], ngImport: i0, template: "<div\n    *ngIf=\"cellIndex === 0\"\n    class=\"resizer left-border\"\n    (mousedown)=\"onStartResizing($event, resizerBorder.Left)\"></div>\n<div\n    #container\n    class=\"edit-container\"></div>\n<div class=\"highlight-container\"></div>\n<div\n    class=\"resizer right-border\"\n    (mousedown)=\"onStartResizing($event, resizerBorder.Right)\"></div>\n", styles: [":host{flex:1;display:flex;position:relative}.sidenav-container{width:100%}.container{height:100%;display:flex;justify-content:center}app-element-toolbar{right:15px;top:50px}:host::ng-deep .ace-editor{position:relative;line-height:1;font-size:12pt;font-family:Courier New,Courier,monospace;text-align:left;width:100%;height:100%}:host::ng-deep .ace-scroller{position:absolute;overflow:hidden;top:0;bottom:0;-webkit-user-select:none;user-select:none;cursor:text}:host::ng-deep .ace-scrollbar{overflow:hidden scroll;contain:strict;position:absolute;right:0;bottom:0;z-index:6;top:0}:host::ng-deep .ace-scrollbar-inner{position:absolute;cursor:text;left:0;top:0}:host::ng-deep .ace-text-input{position:absolute;z-index:0;width:.5em;height:1em;opacity:0;background:transparent;appearance:none;border:none;resize:none;overflow:hidden;font:inherit;padding:0 1px;margin:0 -1px;contain:strict;-webkit-user-select:text;user-select:text}:host::ng-deep .ace-layer{z-index:1;position:absolute;word-wrap:normal;white-space:pre;height:100%;width:100%;box-sizing:border-box;pointer-events:none}:host::ng-deep .ace-text-layer{font:inherit!important;position:absolute;contain:style size layout;pointer-events:auto}:host::ng-deep .ace-edges-layer{z-index:2}:host::ng-deep .ace-line{display:flex;align-items:baseline;line-height:normal}:host::ng-deep .ace-line .hyperlink-hover{cursor:pointer}:host::ng-deep .ace-line>*{display:inline-block;font-kerning:none}:host::ng-deep .ace-line>*.paragraph-symbol{align-self:flex-end}:host::ng-deep .ace-content{position:inherit;box-sizing:border-box;min-width:100%;contain:style size layout;inset:0}:host::ng-deep .ace-line-group{display:inline-flex}:host::ng-deep .ace-line-group .lines-container{width:100%}:host::ng-deep .ace-line-group .numberingMarker{display:inline-flex}:host::ng-deep .ace-line-group .numberingMarker span{align-self:end}:host::ng-deep .ace-text-layer>.ace-line,:host::ng-deep .ace-text-layer>.ace-line-group,:host::ng-deep .ace-edges-layer>.ace-line,:host::ng-deep .ace-edges-layer>.ace-line-group{contain:style size layout;position:absolute;top:0;left:0;right:0}:host::ng-deep .ace-text-layer>.ace-line-group:has(.focused){z-index:1}:host::ng-deep .ace-line-group:has(.lines-container>.ace-line:first-child>span:not(:empty)){align-items:baseline}:host::ng-deep .ace-cursor-layer{z-index:4}:host::ng-deep .ace-cursor-layer.selecting{display:none}:host::ng-deep .ace-cursor{z-index:4;position:absolute;box-sizing:border-box;border-left:2px solid;transform:translateZ(0)}:host::ng-deep .ace-hidden-cursors .ace-cursor{opacity:0}:host::ng-deep .ace-hidden-cursors{visibility:hidden}:host::ng-deep .ace-animate-blinking .ace-cursor{animation-duration:1s;animation-timing-function:step-end;animation-name:blink-ace-animate;animation-iteration-count:infinite}:host::ng-deep .ace-animate-blinking.ace-smooth-blinking .ace-cursor{animation-duration:1s;animation-timing-function:ease-in-out;animation-name:blink-ace-animate-smooth}@keyframes blink-ace-animate{0%,to{opacity:1}60%{opacity:0}}@keyframes blink-ace-animate-smooth{0%,to{opacity:1}45%{opacity:1}60%{opacity:0}85%{opacity:0}}:host::ng-deep .ace-selection-layer .ace-selection{position:absolute;z-index:5}:host::ng-deep .ace-selection-layer.text-selection .ace-selection{background-color:#5ea8f766}:host::ng-deep .ace-selection-layer.notes-highlight .ace-selection{background:#ff06}:host::ng-deep .ace-underline{text-decoration:underline}:host::ng-deep .ace-bold{font-weight:700}:host::ng-deep .ace-italic{font-style:italic}:host::ng-deep .page{width:100%;position:absolute}:host::ng-deep .page-label{position:absolute;top:40px;right:96px;font-family:Courier New,Courier,monospace;font-size:16px;line-height:1}:host::ng-deep .font-baseline{visibility:hidden;height:500px}:host::ng-deep .font-baseline span:after{content:\"\";height:100%;display:inline-block}:host::ng-deep .ruler-line{position:absolute;top:0;bottom:0;width:0;border-left:1px solid rgba(0,0,0,.4);opacity:.5;display:none;z-index:1}:host::ng-deep .ruler-line.visible{display:block}:host::ng-deep .drawer-container .mat-button-toggle-button{height:48px;border-radius:4px}:host::ng-deep .drawer-container .mat-button-toggle-checked button{height:48px;border-radius:4px}\n", ".highlight-container{visibility:hidden;position:absolute;width:100%;height:100%;background-color:#5ea8f766;pointer-events:none;overflow:hidden}:host{min-height:19px;height:100%;background:transparent}:host.highlighted .highlight-container{visibility:visible}.edit-container{min-height:1px;overflow:hidden}.left-border{left:-6px}.resizer{cursor:col-resize;width:11px;height:100%;position:absolute;z-index:1}.right-border{right:-6px}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NoderTableCellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-noder-table-cell', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n    *ngIf=\"cellIndex === 0\"\n    class=\"resizer left-border\"\n    (mousedown)=\"onStartResizing($event, resizerBorder.Left)\"></div>\n<div\n    #container\n    class=\"edit-container\"></div>\n<div class=\"highlight-container\"></div>\n<div\n    class=\"resizer right-border\"\n    (mousedown)=\"onStartResizing($event, resizerBorder.Right)\"></div>\n", styles: [":host{flex:1;display:flex;position:relative}.sidenav-container{width:100%}.container{height:100%;display:flex;justify-content:center}app-element-toolbar{right:15px;top:50px}:host::ng-deep .ace-editor{position:relative;line-height:1;font-size:12pt;font-family:Courier New,Courier,monospace;text-align:left;width:100%;height:100%}:host::ng-deep .ace-scroller{position:absolute;overflow:hidden;top:0;bottom:0;-webkit-user-select:none;user-select:none;cursor:text}:host::ng-deep .ace-scrollbar{overflow:hidden scroll;contain:strict;position:absolute;right:0;bottom:0;z-index:6;top:0}:host::ng-deep .ace-scrollbar-inner{position:absolute;cursor:text;left:0;top:0}:host::ng-deep .ace-text-input{position:absolute;z-index:0;width:.5em;height:1em;opacity:0;background:transparent;appearance:none;border:none;resize:none;overflow:hidden;font:inherit;padding:0 1px;margin:0 -1px;contain:strict;-webkit-user-select:text;user-select:text}:host::ng-deep .ace-layer{z-index:1;position:absolute;word-wrap:normal;white-space:pre;height:100%;width:100%;box-sizing:border-box;pointer-events:none}:host::ng-deep .ace-text-layer{font:inherit!important;position:absolute;contain:style size layout;pointer-events:auto}:host::ng-deep .ace-edges-layer{z-index:2}:host::ng-deep .ace-line{display:flex;align-items:baseline;line-height:normal}:host::ng-deep .ace-line .hyperlink-hover{cursor:pointer}:host::ng-deep .ace-line>*{display:inline-block;font-kerning:none}:host::ng-deep .ace-line>*.paragraph-symbol{align-self:flex-end}:host::ng-deep .ace-content{position:inherit;box-sizing:border-box;min-width:100%;contain:style size layout;inset:0}:host::ng-deep .ace-line-group{display:inline-flex}:host::ng-deep .ace-line-group .lines-container{width:100%}:host::ng-deep .ace-line-group .numberingMarker{display:inline-flex}:host::ng-deep .ace-line-group .numberingMarker span{align-self:end}:host::ng-deep .ace-text-layer>.ace-line,:host::ng-deep .ace-text-layer>.ace-line-group,:host::ng-deep .ace-edges-layer>.ace-line,:host::ng-deep .ace-edges-layer>.ace-line-group{contain:style size layout;position:absolute;top:0;left:0;right:0}:host::ng-deep .ace-text-layer>.ace-line-group:has(.focused){z-index:1}:host::ng-deep .ace-line-group:has(.lines-container>.ace-line:first-child>span:not(:empty)){align-items:baseline}:host::ng-deep .ace-cursor-layer{z-index:4}:host::ng-deep .ace-cursor-layer.selecting{display:none}:host::ng-deep .ace-cursor{z-index:4;position:absolute;box-sizing:border-box;border-left:2px solid;transform:translateZ(0)}:host::ng-deep .ace-hidden-cursors .ace-cursor{opacity:0}:host::ng-deep .ace-hidden-cursors{visibility:hidden}:host::ng-deep .ace-animate-blinking .ace-cursor{animation-duration:1s;animation-timing-function:step-end;animation-name:blink-ace-animate;animation-iteration-count:infinite}:host::ng-deep .ace-animate-blinking.ace-smooth-blinking .ace-cursor{animation-duration:1s;animation-timing-function:ease-in-out;animation-name:blink-ace-animate-smooth}@keyframes blink-ace-animate{0%,to{opacity:1}60%{opacity:0}}@keyframes blink-ace-animate-smooth{0%,to{opacity:1}45%{opacity:1}60%{opacity:0}85%{opacity:0}}:host::ng-deep .ace-selection-layer .ace-selection{position:absolute;z-index:5}:host::ng-deep .ace-selection-layer.text-selection .ace-selection{background-color:#5ea8f766}:host::ng-deep .ace-selection-layer.notes-highlight .ace-selection{background:#ff06}:host::ng-deep .ace-underline{text-decoration:underline}:host::ng-deep .ace-bold{font-weight:700}:host::ng-deep .ace-italic{font-style:italic}:host::ng-deep .page{width:100%;position:absolute}:host::ng-deep .page-label{position:absolute;top:40px;right:96px;font-family:Courier New,Courier,monospace;font-size:16px;line-height:1}:host::ng-deep .font-baseline{visibility:hidden;height:500px}:host::ng-deep .font-baseline span:after{content:\"\";height:100%;display:inline-block}:host::ng-deep .ruler-line{position:absolute;top:0;bottom:0;width:0;border-left:1px solid rgba(0,0,0,.4);opacity:.5;display:none;z-index:1}:host::ng-deep .ruler-line.visible{display:block}:host::ng-deep .drawer-container .mat-button-toggle-button{height:48px;border-radius:4px}:host::ng-deep .drawer-container .mat-button-toggle-checked button{height:48px;border-radius:4px}\n", ".highlight-container{visibility:hidden;position:absolute;width:100%;height:100%;background-color:#5ea8f766;pointer-events:none;overflow:hidden}:host{min-height:19px;height:100%;background:transparent}:host.highlighted .highlight-container{visibility:visible}.edit-container{min-height:1px;overflow:hidden}.left-border{left:-6px}.resizer{cursor:col-resize;width:11px;height:100%;position:absolute;z-index:1}.right-border{right:-6px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.EditorService }, { type: i2.RegulatorService }], propDecorators: { table: [{
+                type: Input
+            }], cell: [{
+                type: Input
+            }], rowIndex: [{
+                type: Input
+            }], cellIndex: [{
+                type: Input
+            }], columnIndex: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], parentSessionId: [{
+                type: Input
+            }], heightChanged: [{
+                type: Input
+            }], startResizing: [{
+                type: Input
+            }], isHighlighted: [{
+                type: HostBinding,
+                args: ['class.highlighted']
+            }], sessionId: [{
+                type: HostBinding,
+                args: ['attr.data-session-id']
+            }], container: [{
+                type: ViewChild,
+                args: ['container', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-cell.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/ngx-noder/src/lib/+shared/editor/custom-components/table/components/table-cell.component.ts","../../../../../../../../../projects/ngx-noder/src/lib/+shared/editor/custom-components/table/components/table-cell.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, ElementRef, HostBinding, Input, ViewChild } from '@angular/core';\n\nimport { CellModel } from '../../../../../models/generated/cell.model';\nimport { CellResizerParametersModel } from '../models/cell-resizer-parameters.model';\nimport { EditSession } from '../../../core/edit.session';\nimport { EditorService } from '../../../interaction/editor.service';\nimport { GeneralPropertiesModel } from '../../../execution/models/general-properties.model';\nimport { MarginModel } from '../../../core/models/margin.model';\nimport { RegulatorService } from '../../../execution/regulator.service';\nimport { Renderer } from '../../../core/renderer';\nimport { ResizerSide } from '../enums/reisizer-side.enum';\nimport { SessionModel } from '../../../execution/models/session.model';\nimport { TableModel } from '../../../../../models/generated/table.model';\nimport { VirtualRenderer } from '../../../core/virtual.renderer';\n\n@Component({\n    selector: 'app-noder-table-cell',\n    templateUrl: './table-cell.component.html',\n    styleUrls: ['../../../editor.component.scss', './table-cell.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class NoderTableCellComponent {\n    @Input() table: TableModel;\n\n    @Input() cell: CellModel;\n\n    @Input() rowIndex: number;\n\n    @Input() cellIndex: number;\n\n    @Input() columnIndex: number;\n\n    @Input() width: number;\n\n    @Input() parentSessionId: number;\n\n    @Input() heightChanged: (rowIndex: number, cellIndex: number, height: number) => void;\n\n    @Input() startResizing: (cellResizerParameters: CellResizerParametersModel) => void;\n\n    @HostBinding('class.highlighted')\n    isHighlighted = false;\n\n    @HostBinding('attr.data-session-id')\n    sessionId: number;\n\n    cellSession: SessionModel;\n\n    properties: GeneralPropertiesModel;\n\n    get session(): EditSession {\n        return this.cellSession.session;\n    }\n\n    get renderer(): Renderer | VirtualRenderer {\n        return this.cellSession.renderer;\n    }\n\n    @ViewChild('container', { static: true }) container: ElementRef<HTMLElement>;\n\n    readonly resizerBorder = ResizerSide;\n\n    private _allParagraphsHeight: number;\n\n    constructor(private editorService: EditorService, private regulatorService: RegulatorService) {}\n\n    ngOnDestroy(): void {\n        this.session?.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n        this.regulatorService.removeSession(this.sessionId);\n    }\n\n    initialize(): void {\n        const marginModel = new MarginModel({\n            left: 7,\n            right: 7,\n            top: 0,\n            bottom: 0,\n            header: 0,\n            footer: 0\n        });\n        this.cellSession = this.regulatorService.addCellSession(this.table, marginModel, this, this.properties);\n        this.sessionId = this.cellSession.sessionId;\n        this.addEventListeners();\n    }\n\n    getCellContentHeight(): number {\n        this._allParagraphsHeight = this.session.pagesWrap.getAllParagraphsHeight();\n        return this._allParagraphsHeight;\n    }\n\n    clearSelection(): void {\n        this.editorService.clearSelection();\n    }\n\n    onStartResizing(event: MouseEvent, border: ResizerSide): void {\n        event.stopPropagation();\n\n        this.startResizing(new CellResizerParametersModel(this.columnIndex, this.rowIndex, this.cellIndex, border));\n    }\n\n    private addEventListeners(): void {\n        this.session.pagesWrap.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n    }\n\n    private pagesCountChangedHandler = (event: { pageHeight: number }): void => {\n        if (this._allParagraphsHeight === event.pageHeight) {\n            return;\n        }\n\n        this._allParagraphsHeight = event.pageHeight;\n        const cellContentHeight = this._allParagraphsHeight;\n        this.heightChanged(this.rowIndex, this.cellIndex, cellContentHeight);\n    };\n}\n","<div\n    *ngIf=\"cellIndex === 0\"\n    class=\"resizer left-border\"\n    (mousedown)=\"onStartResizing($event, resizerBorder.Left)\"></div>\n<div\n    #container\n    class=\"edit-container\"></div>\n<div class=\"highlight-container\"></div>\n<div\n    class=\"resizer right-border\"\n    (mousedown)=\"onStartResizing($event, resizerBorder.Right)\"></div>\n"]}

package/esm2022/lib/+shared/editor/custom-components/table/components/table.component.mjs

@@ -0,0 +1,293 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { BaseNoderComponent } from '../../shared/abstract/base.component';
+import { CellDataModel } from '../models/cell-data.model';
+import { CellResizer } from '../cell-resizer/cell-resizer';
+import { HRule } from '../../../core/enums/hrule.enum';
+import { NoderTableCellComponent } from './table-cell.component';
+import { RowDataModel } from '../models/row-data.model';
+import { TableSelection } from '../selection/table-selection';
+import { VerticalMerge } from '../enums/vertical-merge.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../shared/services/component/component.service";
+import * as i2 from "../../../interaction/editor.service";
+import * as i3 from "../../shared/services/overlay/overlay.service";
+export class NoderTableComponent extends BaseNoderComponent {
+    get table() {
+        return this.content;
+    }
+    set table(val) {
+        this.content = val;
+    }
+    constructor(componentService, editorService, el, overlayService) {
+        super();
+        this.componentService = componentService;
+        this.editorService = editorService;
+        this.el = el;
+        this.overlayService = overlayService;
+        this.rowMatrix = [];
+        this.minRowHeight = 19;
+        this.borderSize = 0.8;
+        this.startResizing = (cellResizerParameters) => {
+            this.resizer.resizerHeight = this.height;
+            this.resizer.tableInsertIndex = this.insertIndex;
+            this.resizer.onStartResizing(cellResizerParameters);
+        };
+        this.cellHeightChanged = (rowIndex, cellIndex, height) => {
+            const tableRow = this.table.rows[rowIndex];
+            this.rowMatrix[rowIndex].cells[cellIndex].cellContentHeight = height < this.minRowHeight ? this.minRowHeight : height;
+            if (tableRow.hRule === HRule.Exact) {
+                return;
+            }
+            const row = this.tableEl.rows[rowIndex];
+            const currentHeight = row.offsetHeight;
+            const cellHeights = this.rowMatrix[rowIndex].cells.map(x => x.cellContentHeight);
+            const maxCellContentHeigh = Math.max(...cellHeights, height);
+            if (maxCellContentHeigh > currentHeight ||
+                (maxCellContentHeigh < currentHeight && (!tableRow.height || tableRow.height <= maxCellContentHeigh))) {
+                row.style.height = `${maxCellContentHeigh}px`;
+                this.rowMatrix[rowIndex].height = maxCellContentHeigh;
+                this.setTableHeight();
+                this.editorService.changedTableSize(this.insertIndex, this.sessionId);
+            }
+        };
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.tableSelection?.destroy();
+    }
+    initialize() {
+        this.createTable();
+        this.calculateProperties();
+        this.createResizer();
+        this.el.nativeElement.appendChild(this.resizerEl);
+        this.el.nativeElement.appendChild(this.tableEl);
+        this.tableSelection = new TableSelection(this.editorService, this.overlayService, this.rowMatrix, this.table, this.tableEl, this.sessionId);
+    }
+    getCellSession(row, column) {
+        return this.rowMatrix[row].cells[column].componentRef.instance.session;
+    }
+    getCellWidth(tableRow, cellIndex, absoluteCellIndex) {
+        if (tableRow.cells[cellIndex].width) {
+            return tableRow.cells[cellIndex].width;
+        }
+        let width = 0;
+        let i = absoluteCellIndex;
+        const cellSpanCount = absoluteCellIndex + tableRow.cells[cellIndex].horizontalMerge;
+        do {
+            width += this.table.columns[i].width;
+            i++;
+        } while (i < cellSpanCount);
+        return width;
+    }
+    createResizer() {
+        this.resizerEl = document.createElement('div');
+        this.resizerEl.className = 'resizer-border';
+        this.resizerEl.setAttribute('style', `display:none;`);
+        this.resizer = new CellResizer(this.table, this.tableEl, this.editorService, this.resizerEl);
+        this.resizer.sessionId = this.sessionId;
+    }
+    createTable() {
+        this.tableEl = document.createElement('table');
+        this.setColgroup();
+        this.insertRows(this.table.rows.length, 0);
+        this.fillTableCells();
+    }
+    updateTable() {
+        const cells = [].concat(...this.rowMatrix.map(x => x.cells));
+        const uniqCells = new Set(cells.map(x => x.componentRef));
+        uniqCells.forEach(x => this.componentService.removeComponent(x));
+        this.tableSelection.destroy();
+        this.rowMatrix = [];
+        this.tableEl.remove();
+        this.initialize();
+    }
+    insertRows(rowsCount, targetIndex) {
+        let rowIndex = 0;
+        while (rowIndex < rowsCount) {
+            const targetRowIndex = targetIndex + rowIndex;
+            const row = this.tableEl.insertRow(targetRowIndex);
+            this.rowMatrix.splice(targetRowIndex, 0, new RowDataModel(row, 0, []));
+            this.insertCells(targetRowIndex, this.table.rows[targetRowIndex].cells.length, 0);
+            rowIndex++;
+        }
+        this.fillTableRow();
+    }
+    insertCells(rowIndex, cellsCount, targetIndex) {
+        let modelTargetIndex = this.getModelTargetIndex(rowIndex, targetIndex);
+        this.addCells(rowIndex, cellsCount, targetIndex, modelTargetIndex);
+    }
+    getModelTargetIndex(rowIndex, targetIndex) {
+        let absoluteModelCellCount = 0;
+        let modelTargetIndex = 0;
+        while (absoluteModelCellCount < targetIndex) {
+            absoluteModelCellCount += this.table.rows[rowIndex].cells[modelTargetIndex].horizontalMerge ?? 1;
+            if (absoluteModelCellCount > targetIndex) {
+                break;
+            }
+            modelTargetIndex++;
+        }
+        return modelTargetIndex;
+    }
+    addCells(rowIndex, cellsCount, targetIndex, modelTargetIndex) {
+        let i = 0;
+        let currentTargetIndex = targetIndex;
+        while (i < cellsCount) {
+            const modelCellIndex = modelTargetIndex + i;
+            if (this.table.rows[rowIndex].cells[modelCellIndex].verticalMerge === VerticalMerge.Merge) {
+                const inheritCellData = this.rowMatrix[rowIndex - 1].cells[currentTargetIndex];
+                const count = this.table.rows[rowIndex].cells[modelCellIndex].horizontalMerge ?? 1;
+                this.addAdditionalCells(rowIndex, currentTargetIndex, count, inheritCellData);
+                currentTargetIndex += count;
+                i++;
+                continue;
+            }
+            const cell = this.tableEl.rows[rowIndex].insertCell(currentTargetIndex);
+            const componentRef = this.componentService.generateAndAttachComponent(cell, NoderTableCellComponent, {
+                table: this.table,
+                cell: this.table.rows[rowIndex].cells[modelCellIndex],
+                parentSessionId: this.sessionId,
+                rowIndex,
+                cellIndex: modelCellIndex,
+                columnIndex: currentTargetIndex,
+                width: this.getCellWidth(this.table.rows[rowIndex], modelCellIndex, currentTargetIndex),
+                heightChanged: this.cellHeightChanged,
+                startResizing: this.startResizing,
+                properties: this.properties
+            });
+            const cellContentHeight = componentRef.instance.getCellContentHeight();
+            const cellData = new CellDataModel(cell, cellContentHeight, componentRef);
+            this.rowMatrix[rowIndex].cells.splice(currentTargetIndex, 0, cellData);
+            currentTargetIndex++;
+            if (this.table.rows[rowIndex].cells[modelCellIndex].horizontalMerge > 1) {
+                const count = this.table.rows[rowIndex].cells[modelCellIndex].horizontalMerge - 1;
+                this.addAdditionalCells(rowIndex, currentTargetIndex, count, cellData);
+                currentTargetIndex += count;
+            }
+            i++;
+        }
+    }
+    addAdditionalCells(rowIndex, cellIndex, cellsCount, originalCellData) {
+        for (let j = 0; j < cellsCount; j++) {
+            const additionalCell = this.tableEl.rows[rowIndex].insertCell(cellIndex);
+            additionalCell.classList.add('hidden-cell');
+            const cellData = new CellDataModel(originalCellData.cell, originalCellData.cellContentHeight, originalCellData.componentRef);
+            this.rowMatrix[rowIndex].cells.splice(cellIndex, 0, cellData);
+        }
+    }
+    setColgroup() {
+        const oldColGroups = this.tableEl.getElementsByTagName('colgroup');
+        if (oldColGroups.length) {
+            this.tableEl.removeChild(oldColGroups[0]);
+        }
+        const colgroup = document.createElement('colgroup');
+        let i = 0;
+        while (i < this.table.columns.length) {
+            const col = document.createElement('col');
+            col.style.width = `${this.table.columns[i].width}px`;
+            colgroup.appendChild(col);
+            i++;
+        }
+        this.tableEl.insertAdjacentElement('afterbegin', colgroup);
+    }
+    fillTableRow() {
+        for (let i = 0; i < this.table.rows.length; i++) {
+            switch (this.table.rows[i].hRule) {
+                case HRule.AtLeast: {
+                    const rowHeight = this.getRowHeight(i);
+                    this.tableEl.rows[i].style.minHeight = `${this.table.rows[i].height}px`;
+                    this.tableEl.rows[i].style.height = `${rowHeight}px`;
+                    this.rowMatrix[i].height = rowHeight;
+                    break;
+                }
+                case HRule.Exact:
+                    this.tableEl.rows[i].style.height = `${this.table.rows[i].height}px`;
+                    this.rowMatrix[i].height = this.table.rows[i].height;
+                    break;
+                default: {
+                    const rowHeight = this.getRowHeight(i);
+                    const minRowHeight = this.table.rows[i].height ?? this.minRowHeight;
+                    const resultHeight = minRowHeight > rowHeight ? minRowHeight : rowHeight;
+                    this.tableEl.rows[i].style.height = `${resultHeight}px`;
+                    this.rowMatrix[i].height = resultHeight;
+                    break;
+                }
+            }
+        }
+    }
+    getRowHeight(rowIndex) {
+        const cellHeights = this.rowMatrix[rowIndex].cells.map((x, index) => {
+            if (x.componentRef.instance.cell.verticalMerge === VerticalMerge.Restart) {
+                const isLastVerticalMergedCell = x.cell !== this.rowMatrix[rowIndex + 1]?.cells[index].cell;
+                if (isLastVerticalMergedCell) {
+                    let i = rowIndex - 1;
+                    let currentHeight = x.cellContentHeight;
+                    while (x.cell === this.rowMatrix[i]?.cells[index].cell) {
+                        currentHeight -= this.rowMatrix[i].height;
+                        i--;
+                    }
+                    return currentHeight;
+                }
+                return 0;
+            }
+            return x.cellContentHeight;
+        });
+        return Math.max(...cellHeights);
+    }
+    fillTableCells() {
+        for (let i = 0; i < this.rowMatrix.length; i++) {
+            for (let j = 0; j < this.rowMatrix[i].cells.length; j++) {
+                if (this.rowMatrix[i - 1]?.cells[j]?.cell === this.rowMatrix[i].cells[j].cell ||
+                    this.rowMatrix[i].cells[j].cell === this.rowMatrix[i].cells[j - 1]?.cell ||
+                    this.rowMatrix[i].cells[j].componentRef.instance.cell.verticalMerge === VerticalMerge.Merge) {
+                    continue;
+                }
+                this.rowMatrix[i].cells[j].cell.colSpan = this.rowMatrix[i].cells[j].componentRef.instance.cell.horizontalMerge;
+                this.rowMatrix[i].cells[j].cell.style.backgroundColor =
+                    this.rowMatrix[i].cells[j].componentRef.instance.cell.backgroundColor;
+                this.setCellRowSpan(i, j);
+            }
+        }
+    }
+    setCellRowSpan(rowIndex, absoluteCellIndex) {
+        this.rowMatrix[rowIndex].cells[absoluteCellIndex].cell.rowSpan = 1;
+        if (this.rowMatrix[rowIndex].cells[absoluteCellIndex].componentRef.instance.cell.verticalMerge !==
+            VerticalMerge.Restart) {
+            return;
+        }
+        for (let i = rowIndex + 1; i < this.rowMatrix.length; i++) {
+            if (this.rowMatrix[i].cells[absoluteCellIndex].cell === this.rowMatrix[rowIndex].cells[absoluteCellIndex].cell) {
+                this.rowMatrix[rowIndex].cells[absoluteCellIndex].cell.rowSpan++;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    setTableHeight() {
+        let bordersHeight = 0;
+        let rowsHeight = 1;
+        for (let row of this.rowMatrix) {
+            rowsHeight += row.height;
+            if (row.cells.some(x => !x.componentRef.instance.cell.verticalMerge)) {
+                bordersHeight += this.borderSize;
+            }
+        }
+        this._height = rowsHeight + bordersHeight;
+    }
+    calculateProperties() {
+        if (!this.tableEl) {
+            return;
+        }
+        this.setTableHeight();
+        const bordersSize = this.borderSize * this.table.columns.length;
+        const width = this.table.columns.reduce((prev, next) => prev + next.width, 1);
+        this._width = width + bordersSize;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NoderTableComponent, deps: [{ token: i1.ComponentService }, { token: i2.EditorService }, { token: i0.ElementRef }, { token: i3.OverlayService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: NoderTableComponent, selector: "app-noder-table", usesInheritance: true, ngImport: i0, template: '', isInline: true, styles: [":host ::ng-deep table{position:relative;border-collapse:collapse;background:transparent;empty-cells:show;border-spacing:0;overflow:visible;table-layout:fixed}:host ::ng-deep td{position:relative;vertical-align:top;border:1px solid #000;margin:0;padding:0;height:inherit}:host ::ng-deep .hidden-cell{display:none;cursor:not-allowed}:host ::ng-deep .resizer-border{position:absolute;border:solid .5px blue;z-index:1}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NoderTableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-noder-table', template: '', changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host ::ng-deep table{position:relative;border-collapse:collapse;background:transparent;empty-cells:show;border-spacing:0;overflow:visible;table-layout:fixed}:host ::ng-deep td{position:relative;vertical-align:top;border:1px solid #000;margin:0;padding:0;height:inherit}:host ::ng-deep .hidden-cell{display:none;cursor:not-allowed}:host ::ng-deep .resizer-border{position:absolute;border:solid .5px blue;z-index:1}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ComponentService }, { type: i2.EditorService }, { type: i0.ElementRef }, { type: i3.OverlayService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/ngx-noder/src/lib/+shared/editor/custom-components/table/components/table.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, ElementRef, OnDestroy } from '@angular/core';\n\nimport { BaseNoderComponent } from '../../shared/abstract/base.component';\nimport { CellDataModel } from '../models/cell-data.model';\nimport { CellResizer } from '../cell-resizer/cell-resizer';\nimport { CellResizerParametersModel } from '../models/cell-resizer-parameters.model';\nimport { ComponentService } from '../../shared/services/component/component.service';\nimport { EditSession } from '../../../core/edit.session';\nimport { EditorService } from '../../../interaction/editor.service';\nimport { GeneralPropertiesModel } from '../../../execution/models/general-properties.model';\nimport { HRule } from '../../../core/enums/hrule.enum';\nimport { NoderTableCellComponent } from './table-cell.component';\nimport { OverlayService } from '../../shared/services/overlay/overlay.service';\nimport { RowDataModel } from '../models/row-data.model';\nimport { RowModel } from '../../../../../models/generated/row.model';\nimport { TableModel } from '../../../../../models/generated/table.model';\nimport { TableSelection } from '../selection/table-selection';\nimport { VerticalMerge } from '../enums/vertical-merge.enum';\n\n@Component({\n    selector: 'app-noder-table',\n    template: '',\n    styleUrls: ['./table.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class NoderTableComponent extends BaseNoderComponent implements OnDestroy {\n    get table(): TableModel {\n        return this.content as TableModel;\n    }\n    set table(val: TableModel) {\n        this.content = val;\n    }\n\n    tableSelection: TableSelection;\n\n    tableEl: HTMLTableElement;\n\n    resizer: CellResizer;\n\n    resizerEl: HTMLDivElement;\n\n    rowMatrix: RowDataModel[] = [];\n\n    properties: GeneralPropertiesModel;\n\n    readonly minRowHeight = 19;\n\n    readonly borderSize = 0.8;\n\n    constructor(\n        private componentService: ComponentService,\n        private editorService: EditorService,\n        private el: ElementRef,\n        private overlayService: OverlayService\n    ) {\n        super();\n    }\n\n    override ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this.tableSelection?.destroy();\n    }\n\n    initialize(): void {\n        this.createTable();\n        this.calculateProperties();\n        this.createResizer();\n        this.el.nativeElement.appendChild(this.resizerEl);\n        this.el.nativeElement.appendChild(this.tableEl);\n        this.tableSelection = new TableSelection(\n            this.editorService,\n            this.overlayService,\n            this.rowMatrix,\n            this.table,\n            this.tableEl,\n            this.sessionId\n        );\n    }\n\n    getCellSession(row: number, column: number): EditSession {\n        return this.rowMatrix[row].cells[column].componentRef.instance.session;\n    }\n\n    getCellWidth(tableRow: RowModel, cellIndex: number, absoluteCellIndex: number): number {\n        if (tableRow.cells[cellIndex].width) {\n            return tableRow.cells[cellIndex].width;\n        }\n\n        let width = 0;\n        let i = absoluteCellIndex;\n        const cellSpanCount = absoluteCellIndex + tableRow.cells[cellIndex].horizontalMerge;\n\n        do {\n            width += this.table.columns[i].width;\n            i++;\n        } while (i < cellSpanCount);\n\n        return width;\n    }\n\n    createResizer(): void {\n        this.resizerEl = document.createElement('div');\n        this.resizerEl.className = 'resizer-border';\n        this.resizerEl.setAttribute('style', `display:none;`);\n        this.resizer = new CellResizer(this.table, this.tableEl, this.editorService, this.resizerEl);\n        this.resizer.sessionId = this.sessionId;\n    }\n\n    createTable(): void {\n        this.tableEl = document.createElement('table');\n        this.setColgroup();\n        this.insertRows(this.table.rows.length, 0);\n        this.fillTableCells();\n    }\n\n    updateTable(): void {\n        const cells = [].concat(...this.rowMatrix.map(x => x.cells)) as CellDataModel[];\n        const uniqCells = new Set(cells.map(x => x.componentRef));\n        uniqCells.forEach(x => this.componentService.removeComponent(x));\n        this.tableSelection.destroy();\n        this.rowMatrix = [];\n        this.tableEl.remove();\n        this.initialize();\n    }\n\n    insertRows(rowsCount: number, targetIndex: number): void {\n        let rowIndex = 0;\n\n        while (rowIndex < rowsCount) {\n            const targetRowIndex = targetIndex + rowIndex;\n            const row = this.tableEl.insertRow(targetRowIndex);\n            this.rowMatrix.splice(targetRowIndex, 0, new RowDataModel(row, 0, []));\n            this.insertCells(targetRowIndex, this.table.rows[targetRowIndex].cells.length, 0);\n            rowIndex++;\n        }\n\n        this.fillTableRow();\n    }\n\n    insertCells(rowIndex: number, cellsCount: number, targetIndex: number): void {\n        let modelTargetIndex = this.getModelTargetIndex(rowIndex, targetIndex);\n        this.addCells(rowIndex, cellsCount, targetIndex, modelTargetIndex);\n    }\n\n    getModelTargetIndex(rowIndex: number, targetIndex: number): number {\n        let absoluteModelCellCount = 0;\n        let modelTargetIndex = 0;\n\n        while (absoluteModelCellCount < targetIndex) {\n            absoluteModelCellCount += this.table.rows[rowIndex].cells[modelTargetIndex].horizontalMerge ?? 1;\n\n            if (absoluteModelCellCount > targetIndex) {\n                break;\n            }\n\n            modelTargetIndex++;\n        }\n\n        return modelTargetIndex;\n    }\n\n    addCells(rowIndex: number, cellsCount: number, targetIndex: number, modelTargetIndex: number): void {\n        let i = 0;\n        let currentTargetIndex = targetIndex;\n\n        while (i < cellsCount) {\n            const modelCellIndex = modelTargetIndex + i;\n\n            if ((this.table.rows[rowIndex].cells[modelCellIndex].verticalMerge as VerticalMerge) === VerticalMerge.Merge) {\n                const inheritCellData = this.rowMatrix[rowIndex - 1].cells[currentTargetIndex];\n                const count = this.table.rows[rowIndex].cells[modelCellIndex].horizontalMerge ?? 1;\n                this.addAdditionalCells(rowIndex, currentTargetIndex, count, inheritCellData);\n                currentTargetIndex += count;\n                i++;\n                continue;\n            }\n\n            const cell = this.tableEl.rows[rowIndex].insertCell(currentTargetIndex);\n            const componentRef = this.componentService.generateAndAttachComponent(cell, NoderTableCellComponent, {\n                table: this.table,\n                cell: this.table.rows[rowIndex].cells[modelCellIndex],\n                parentSessionId: this.sessionId,\n                rowIndex,\n                cellIndex: modelCellIndex,\n                columnIndex: currentTargetIndex,\n                width: this.getCellWidth(this.table.rows[rowIndex], modelCellIndex, currentTargetIndex),\n                heightChanged: this.cellHeightChanged,\n                startResizing: this.startResizing,\n                properties: this.properties\n            });\n            const cellContentHeight = componentRef.instance.getCellContentHeight();\n            const cellData = new CellDataModel(cell, cellContentHeight, componentRef);\n            this.rowMatrix[rowIndex].cells.splice(currentTargetIndex, 0, cellData);\n            currentTargetIndex++;\n\n            if (this.table.rows[rowIndex].cells[modelCellIndex].horizontalMerge > 1) {\n                const count = this.table.rows[rowIndex].cells[modelCellIndex].horizontalMerge - 1;\n                this.addAdditionalCells(rowIndex, currentTargetIndex, count, cellData);\n                currentTargetIndex += count;\n            }\n\n            i++;\n        }\n    }\n\n    addAdditionalCells(rowIndex: number, cellIndex: number, cellsCount: number, originalCellData: CellDataModel): void {\n        for (let j = 0; j < cellsCount; j++) {\n            const additionalCell = this.tableEl.rows[rowIndex].insertCell(cellIndex);\n            additionalCell.classList.add('hidden-cell');\n            const cellData = new CellDataModel(originalCellData.cell, originalCellData.cellContentHeight, originalCellData.componentRef);\n            this.rowMatrix[rowIndex].cells.splice(cellIndex, 0, cellData);\n        }\n    }\n\n    setColgroup(): void {\n        const oldColGroups = this.tableEl.getElementsByTagName('colgroup');\n\n        if (oldColGroups.length) {\n            this.tableEl.removeChild(oldColGroups[0]);\n        }\n\n        const colgroup = document.createElement('colgroup');\n        let i = 0;\n\n        while (i < this.table.columns.length) {\n            const col = document.createElement('col');\n            col.style.width = `${this.table.columns[i].width}px`;\n            colgroup.appendChild(col);\n            i++;\n        }\n\n        this.tableEl.insertAdjacentElement('afterbegin', colgroup);\n    }\n\n    fillTableRow(): void {\n        for (let i = 0; i < this.table.rows.length; i++) {\n            switch (this.table.rows[i].hRule) {\n                case HRule.AtLeast: {\n                    const rowHeight = this.getRowHeight(i);\n                    this.tableEl.rows[i].style.minHeight = `${this.table.rows[i].height}px`;\n                    this.tableEl.rows[i].style.height = `${rowHeight}px`;\n                    this.rowMatrix[i].height = rowHeight;\n                    break;\n                }\n                case HRule.Exact:\n                    this.tableEl.rows[i].style.height = `${this.table.rows[i].height}px`;\n                    this.rowMatrix[i].height = this.table.rows[i].height;\n                    break;\n                default: {\n                    const rowHeight = this.getRowHeight(i);\n                    const minRowHeight = this.table.rows[i].height ?? this.minRowHeight;\n                    const resultHeight = minRowHeight > rowHeight ? minRowHeight : rowHeight;\n                    this.tableEl.rows[i].style.height = `${resultHeight}px`;\n                    this.rowMatrix[i].height = resultHeight;\n                    break;\n                }\n            }\n        }\n    }\n\n    getRowHeight(rowIndex: number): number {\n        const cellHeights = this.rowMatrix[rowIndex].cells.map((x, index) => {\n            if ((x.componentRef.instance.cell.verticalMerge as VerticalMerge) === VerticalMerge.Restart) {\n                const isLastVerticalMergedCell = x.cell !== this.rowMatrix[rowIndex + 1]?.cells[index].cell;\n\n                if (isLastVerticalMergedCell) {\n                    let i = rowIndex - 1;\n                    let currentHeight = x.cellContentHeight;\n\n                    while (x.cell === this.rowMatrix[i]?.cells[index].cell) {\n                        currentHeight -= this.rowMatrix[i].height;\n                        i--;\n                    }\n\n                    return currentHeight;\n                }\n\n                return 0;\n            }\n\n            return x.cellContentHeight;\n        });\n\n        return Math.max(...cellHeights);\n    }\n\n    fillTableCells(): void {\n        for (let i = 0; i < this.rowMatrix.length; i++) {\n            for (let j = 0; j < this.rowMatrix[i].cells.length; j++) {\n                if (\n                    this.rowMatrix[i - 1]?.cells[j]?.cell === this.rowMatrix[i].cells[j].cell ||\n                    this.rowMatrix[i].cells[j].cell === this.rowMatrix[i].cells[j - 1]?.cell ||\n                    (this.rowMatrix[i].cells[j].componentRef.instance.cell.verticalMerge as VerticalMerge) === VerticalMerge.Merge\n                ) {\n                    continue;\n                }\n\n                this.rowMatrix[i].cells[j].cell.colSpan = this.rowMatrix[i].cells[j].componentRef.instance.cell.horizontalMerge;\n                this.rowMatrix[i].cells[j].cell.style.backgroundColor =\n                    this.rowMatrix[i].cells[j].componentRef.instance.cell.backgroundColor;\n                this.setCellRowSpan(i, j);\n            }\n        }\n    }\n\n    setCellRowSpan(rowIndex: number, absoluteCellIndex: number): void {\n        this.rowMatrix[rowIndex].cells[absoluteCellIndex].cell.rowSpan = 1;\n\n        if (\n            (this.rowMatrix[rowIndex].cells[absoluteCellIndex].componentRef.instance.cell.verticalMerge as VerticalMerge) !==\n            VerticalMerge.Restart\n        ) {\n            return;\n        }\n\n        for (let i = rowIndex + 1; i < this.rowMatrix.length; i++) {\n            if (this.rowMatrix[i].cells[absoluteCellIndex].cell === this.rowMatrix[rowIndex].cells[absoluteCellIndex].cell) {\n                this.rowMatrix[rowIndex].cells[absoluteCellIndex].cell.rowSpan++;\n            } else {\n                break;\n            }\n        }\n    }\n\n    setTableHeight(): void {\n        let bordersHeight = 0;\n        let rowsHeight = 1;\n\n        for (let row of this.rowMatrix) {\n            rowsHeight += row.height;\n\n            if (row.cells.some(x => !x.componentRef.instance.cell.verticalMerge)) {\n                bordersHeight += this.borderSize;\n            }\n        }\n\n        this._height = rowsHeight + bordersHeight;\n    }\n\n    startResizing = (cellResizerParameters: CellResizerParametersModel): void => {\n        this.resizer.resizerHeight = this.height;\n        this.resizer.tableInsertIndex = this.insertIndex;\n        this.resizer.onStartResizing(cellResizerParameters);\n    };\n\n    protected calculateProperties(): void {\n        if (!this.tableEl) {\n            return;\n        }\n\n        this.setTableHeight();\n\n        const bordersSize = this.borderSize * this.table.columns.length;\n        const width = this.table.columns.reduce((prev, next) => prev + next.width, 1);\n        this._width = width + bordersSize;\n    }\n\n    private cellHeightChanged = (rowIndex: number, cellIndex: number, height: number): void => {\n        const tableRow = this.table.rows[rowIndex];\n        this.rowMatrix[rowIndex].cells[cellIndex].cellContentHeight = height < this.minRowHeight ? this.minRowHeight : height;\n\n        if (tableRow.hRule === HRule.Exact) {\n            return;\n        }\n\n        const row = this.tableEl.rows[rowIndex];\n        const currentHeight = row.offsetHeight;\n        const cellHeights = this.rowMatrix[rowIndex].cells.map(x => x.cellContentHeight);\n        const maxCellContentHeigh = Math.max(...cellHeights, height);\n\n        if (\n            maxCellContentHeigh > currentHeight ||\n            (maxCellContentHeigh < currentHeight && (!tableRow.height || tableRow.height <= maxCellContentHeigh))\n        ) {\n            row.style.height = `${maxCellContentHeigh}px`;\n            this.rowMatrix[rowIndex].height = maxCellContentHeigh;\n            this.setTableHeight();\n            this.editorService.changedTableSize(this.insertIndex, this.sessionId);\n        }\n    };\n}\n"]}

package/esm2022/lib/+shared/editor/custom-components/table/enums/reisizer-side.enum.mjs

@@ -0,0 +1,8 @@
+export var ResizerSide;
+(function (ResizerSide) {
+    ResizerSide[ResizerSide["Left"] = 0] = "Left";
+    ResizerSide[ResizerSide["Top"] = 1] = "Top";
+    ResizerSide[ResizerSide["Right"] = 2] = "Right";
+    ResizerSide[ResizerSide["Bottom"] = 3] = "Bottom";
+})(ResizerSide || (ResizerSide = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVpc2l6ZXItc2lkZS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvK3NoYXJlZC9lZGl0b3IvY3VzdG9tLWNvbXBvbmVudHMvdGFibGUvZW51bXMvcmVpc2l6ZXItc2lkZS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFdBS1g7QUFMRCxXQUFZLFdBQVc7SUFDbkIsNkNBQUksQ0FBQTtJQUNKLDJDQUFHLENBQUE7SUFDSCwrQ0FBSyxDQUFBO0lBQ0wsaURBQU0sQ0FBQTtBQUNWLENBQUMsRUFMVyxXQUFXLEtBQVgsV0FBVyxRQUt0QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFJlc2l6ZXJTaWRlIHtcbiAgICBMZWZ0LFxuICAgIFRvcCxcbiAgICBSaWdodCxcbiAgICBCb3R0b21cbn1cbiJdfQ==

package/esm2022/lib/+shared/editor/custom-components/table/enums/vertical-merge.enum.mjs

@@ -0,0 +1,6 @@
+export var VerticalMerge;
+(function (VerticalMerge) {
+    VerticalMerge["Restart"] = "restart";
+    VerticalMerge["Merge"] = "merge";
+})(VerticalMerge || (VerticalMerge = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVydGljYWwtbWVyZ2UuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliLytzaGFyZWQvZWRpdG9yL2N1c3RvbS1jb21wb25lbnRzL3RhYmxlL2VudW1zL3ZlcnRpY2FsLW1lcmdlLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksYUFHWDtBQUhELFdBQVksYUFBYTtJQUNyQixvQ0FBbUIsQ0FBQTtJQUNuQixnQ0FBZSxDQUFBO0FBQ25CLENBQUMsRUFIVyxhQUFhLEtBQWIsYUFBYSxRQUd4QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFZlcnRpY2FsTWVyZ2Uge1xuICAgIFJlc3RhcnQgPSAncmVzdGFydCcsXG4gICAgTWVyZ2UgPSAnbWVyZ2UnXG59XG4iXX0=

package/esm2022/lib/+shared/editor/custom-components/table/models/cell-data.model.mjs

@@ -0,0 +1,18 @@
+export class CellDataModel {
+    constructor(cell, cellContentHeight, componentRef) {
+        this.cell = cell;
+        this.cellContentHeight = cellContentHeight;
+        this.componentRef = componentRef;
+    }
+    highlightCell() {
+        this.componentRef.instance.isHighlighted = true;
+    }
+    removeHighlightCell() {
+        this.componentRef.instance.isHighlighted = false;
+    }
+    clearSelection() {
+        this.componentRef.instance.clearSelection();
+        this.componentRef.instance.renderer.cursorLayer.hideCursor();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VsbC1kYXRhLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvK3NoYXJlZC9lZGl0b3IvY3VzdG9tLWNvbXBvbmVudHMvdGFibGUvbW9kZWxzL2NlbGwtZGF0YS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sYUFBYTtJQUN0QixZQUNXLElBQTBCLEVBQzFCLGlCQUF5QixFQUN6QixZQUFtRDtRQUZuRCxTQUFJLEdBQUosSUFBSSxDQUFzQjtRQUMxQixzQkFBaUIsR0FBakIsaUJBQWlCLENBQVE7UUFDekIsaUJBQVksR0FBWixZQUFZLENBQXVDO0lBQzNELENBQUM7SUFFRyxhQUFhO1FBQ2hCLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUM7SUFDcEQsQ0FBQztJQUVNLG1CQUFtQjtRQUN0QixJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxhQUFhLEdBQUcsS0FBSyxDQUFDO0lBQ3JELENBQUM7SUFFTSxjQUFjO1FBQ2pCLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQzVDLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDakUsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50UmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IE5vZGVyVGFibGVDZWxsQ29tcG9uZW50IH0gZnJvbSAnLi4vY29tcG9uZW50cy90YWJsZS1jZWxsLmNvbXBvbmVudCc7XG5cbmV4cG9ydCBjbGFzcyBDZWxsRGF0YU1vZGVsIHtcbiAgICBwdWJsaWMgY29uc3RydWN0b3IoXG4gICAgICAgIHB1YmxpYyBjZWxsOiBIVE1MVGFibGVDZWxsRWxlbWVudCxcbiAgICAgICAgcHVibGljIGNlbGxDb250ZW50SGVpZ2h0OiBudW1iZXIsXG4gICAgICAgIHB1YmxpYyBjb21wb25lbnRSZWY6IENvbXBvbmVudFJlZjxOb2RlclRhYmxlQ2VsbENvbXBvbmVudD5cbiAgICApIHt9XG5cbiAgICBwdWJsaWMgaGlnaGxpZ2h0Q2VsbCgpIHtcbiAgICAgICAgdGhpcy5jb21wb25lbnRSZWYuaW5zdGFuY2UuaXNIaWdobGlnaHRlZCA9IHRydWU7XG4gICAgfVxuXG4gICAgcHVibGljIHJlbW92ZUhpZ2hsaWdodENlbGwoKSB7XG4gICAgICAgIHRoaXMuY29tcG9uZW50UmVmLmluc3RhbmNlLmlzSGlnaGxpZ2h0ZWQgPSBmYWxzZTtcbiAgICB9XG5cbiAgICBwdWJsaWMgY2xlYXJTZWxlY3Rpb24oKSB7XG4gICAgICAgIHRoaXMuY29tcG9uZW50UmVmLmluc3RhbmNlLmNsZWFyU2VsZWN0aW9uKCk7XG4gICAgICAgIHRoaXMuY29tcG9uZW50UmVmLmluc3RhbmNlLnJlbmRlcmVyLmN1cnNvckxheWVyLmhpZGVDdXJzb3IoKTtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/+shared/editor/custom-components/table/models/cell-resizer-parameters.model.mjs

@@ -0,0 +1,9 @@
+export class CellResizerParametersModel {
+    constructor(columnIndex, rowIndex, cellIndex, cellSide) {
+        this.columnIndex = columnIndex;
+        this.rowIndex = rowIndex;
+        this.cellIndex = cellIndex;
+        this.cellSide = cellSide;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VsbC1yZXNpemVyLXBhcmFtZXRlcnMubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi8rc2hhcmVkL2VkaXRvci9jdXN0b20tY29tcG9uZW50cy90YWJsZS9tb2RlbHMvY2VsbC1yZXNpemVyLXBhcmFtZXRlcnMubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLDBCQUEwQjtJQUduQyxZQUEwQixXQUFtQixFQUFTLFFBQWdCLEVBQVMsU0FBaUIsRUFBUyxRQUFxQjtRQUFwRyxnQkFBVyxHQUFYLFdBQVcsQ0FBUTtRQUFTLGFBQVEsR0FBUixRQUFRLENBQVE7UUFBUyxjQUFTLEdBQVQsU0FBUyxDQUFRO1FBQVMsYUFBUSxHQUFSLFFBQVEsQ0FBYTtJQUFHLENBQUM7Q0FDckkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXNpemVyU2lkZSB9IGZyb20gJy4uL2VudW1zL3JlaXNpemVyLXNpZGUuZW51bSc7XG5cbmV4cG9ydCBjbGFzcyBDZWxsUmVzaXplclBhcmFtZXRlcnNNb2RlbCB7XG4gICAgcHVibGljIGRpc3RhbmNlOiBudW1iZXI7XG5cbiAgICBwdWJsaWMgY29uc3RydWN0b3IocHVibGljIGNvbHVtbkluZGV4OiBudW1iZXIsIHB1YmxpYyByb3dJbmRleDogbnVtYmVyLCBwdWJsaWMgY2VsbEluZGV4OiBudW1iZXIsIHB1YmxpYyBjZWxsU2lkZTogUmVzaXplclNpZGUpIHt9XG59XG4iXX0=

package/esm2022/lib/+shared/editor/custom-components/table/models/row-data.model.mjs

@@ -0,0 +1,8 @@
+export class RowDataModel {
+    constructor(row, height, cells) {
+        this.row = row;
+        this.height = height;
+        this.cells = cells;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm93LWRhdGEubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi8rc2hhcmVkL2VkaXRvci9jdXN0b20tY29tcG9uZW50cy90YWJsZS9tb2RlbHMvcm93LWRhdGEubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLFlBQVk7SUFDckIsWUFBMEIsR0FBd0IsRUFBUyxNQUFjLEVBQVMsS0FBc0I7UUFBOUUsUUFBRyxHQUFILEdBQUcsQ0FBcUI7UUFBUyxXQUFNLEdBQU4sTUFBTSxDQUFRO1FBQVMsVUFBSyxHQUFMLEtBQUssQ0FBaUI7SUFBRyxDQUFDO0NBQy9HIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2VsbERhdGFNb2RlbCB9IGZyb20gJy4vY2VsbC1kYXRhLm1vZGVsJztcblxuZXhwb3J0IGNsYXNzIFJvd0RhdGFNb2RlbCB7XG4gICAgcHVibGljIGNvbnN0cnVjdG9yKHB1YmxpYyByb3c6IEhUTUxUYWJsZVJvd0VsZW1lbnQsIHB1YmxpYyBoZWlnaHQ6IG51bWJlciwgcHVibGljIGNlbGxzOiBDZWxsRGF0YU1vZGVsW10pIHt9XG59XG4iXX0=

package/esm2022/lib/+shared/editor/custom-components/table/models/selection-range.model.mjs

@@ -0,0 +1,7 @@
+export class SelectionRangeModel {
+    constructor(rowIndexes, cellIndexes) {
+        this.rowIndexes = rowIndexes;
+        this.cellIndexes = cellIndexes;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0aW9uLXJhbmdlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvK3NoYXJlZC9lZGl0b3IvY3VzdG9tLWNvbXBvbmVudHMvdGFibGUvbW9kZWxzL3NlbGVjdGlvbi1yYW5nZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sbUJBQW1CO0lBQzVCLFlBQ1csVUFBb0QsRUFDcEQsV0FBcUQ7UUFEckQsZUFBVSxHQUFWLFVBQVUsQ0FBMEM7UUFDcEQsZ0JBQVcsR0FBWCxXQUFXLENBQTBDO0lBQzdELENBQUM7Q0FDUCIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBTZWxlY3Rpb25SYW5nZU1vZGVsIHtcbiAgICBwdWJsaWMgY29uc3RydWN0b3IoXG4gICAgICAgIHB1YmxpYyByb3dJbmRleGVzOiB7IHN0YXJ0SW5kZXg6IG51bWJlcjsgZW5kSW5kZXg6IG51bWJlciB9LFxuICAgICAgICBwdWJsaWMgY2VsbEluZGV4ZXM6IHsgc3RhcnRJbmRleDogbnVtYmVyOyBlbmRJbmRleDogbnVtYmVyIH1cbiAgICApIHt9XG59XG4iXX0=