@talrace/ngx-noder 19.0.69 → 19.0.70

package/fesm2022/talrace-ngx-noder.mjs

@@ -12566,6 +12566,22 @@ class RegulatorService {
         });
         this.sessions = [];
     }
+    getIndexWithinMainSession() {
+        if (this.currentSession.session.isEdgeOrWithinEdge()) {
+            return 0; // currently there is no mechanism to track pages and get position according valid page for edge
+        }
+        let session = this.currentSession;
+        while (session.parentSessionId) {
+            const parent = this.sessions.find(x => x.sessionId === session.parentSessionId);
+            if (parent.parentSessionId) {
+                session = parent;
+            }
+            else {
+                break;
+            }
+        }
+        return session.source.table.insertIndex;
+    }
     getCurrentSessionTargets() {
         return this.getTargets(this.currentSession);
     }
@@ -12763,7 +12779,7 @@ class NoderTableCellComponent {
                 return;
             }
             this._allParagraphsHeight = event.pageHeight;
-            this.heightChanged(this.rowIndex, this.cellIndex, event.pageHeight);
+            this.heightChanged(this.rowIndex, this.columnIndex, event.pageHeight);
         };
     }
     ngOnDestroy() {
@@ -13157,7 +13173,8 @@ class TableSelection {
                 return;
             }
             const position = this.regulatorService.currentSession.renderer.screenToParagraph(event.clientX, event.clientY);
-            if (!this.session.selection.isEmpty && this.session.isPositionInRange(position, this.session.selection.selectedRange)) {
+            if (!this.session.selection.isEmpty &&
+                this.regulatorService.currentSession.session.isPositionInRange(position, this.session.selection.selectedRange)) {
                 return;
             }
             this.overlayService.close();
@@ -13507,36 +13524,32 @@ class NoderTableComponent extends BaseNoderComponent {
         this.regulatorService = regulatorService;
         this.rowMatrix = [];
         this.splits = [];
-        this.minRowHeight = 19;
+        this.minRowHeight = 18;
         this.borderSize = 1;
         this.RESIZE_MIN_OFFSET = 5;
         this.startResizing = (cellResizerParameters) => {
-            const splitRowIndex = this.getSplitRowIndex(cellResizerParameters.rowIndex);
             const availableTableSpace = this.getAvailableTableSpace();
-            this.resizer.resizerHeight = this.getRowsHeightBetweenSplits(splitRowIndex);
-            this.resizer.startY = this.getRowsHeightBefore(splitRowIndex);
-            this.resizer.splitRowIndex = splitRowIndex;
+            this.resizer.resizerHeight = this.getRowsHeightBetweenSplits(cellResizerParameters.rowIndex);
+            this.resizer.startY = this.getRowsHeightBefore(cellResizerParameters.rowIndex);
+            this.resizer.splitRowIndex = cellResizerParameters.rowIndex;
             this.resizer.tableInsertIndex = this.insertIndex;
             this.resizer.onStartResizing(cellResizerParameters, availableTableSpace);
         };
-        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 rowIndexWithSplit = this.getIndexIncludingSplitRows(this.rowMatrix[rowIndex].row);
-            const row = this.tableEl.rows[rowIndexWithSplit];
-            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);
+        this.cellHeightChanged = (rowIndex, columnIndex, height) => {
+            height = height < this.minRowHeight ? this.minRowHeight : height;
+            let index = rowIndex;
+            do {
+                for (let i = columnIndex; this.rowMatrix[index].cells[columnIndex].cell === this.rowMatrix[index].cells[i]?.cell; i++) {
+                    this.rowMatrix[index].cells[i].cellContentHeight = height;
+                }
+                index++;
+            } while (this.rowMatrix[index - 1].cells[columnIndex].cell === this.rowMatrix[index]?.cells[columnIndex].cell);
+            let isAdjustable = true;
+            for (let i = rowIndex; isAdjustable && i < this.table.rows.length; i++) {
+                isAdjustable = this.fillTableRow(i);
             }
+            this.setTableHeight();
+            this.editorService.changedTableSize(this.insertIndex, this.sessionId);
         };
     }
     ngOnDestroy() {
@@ -13606,7 +13619,9 @@ class NoderTableComponent extends BaseNoderComponent {
             this.insertCells(targetRowIndex, this.table.rows[targetRowIndex].cells.length, 0);
             rowIndex++;
         }
-        this.fillTableRow();
+        for (let i = 0; i < this.table.rows.length; i++) {
+            this.fillTableRow(i);
+        }
     }
     insertCells(rowIndex, cellsCount, targetIndex) {
         let modelTargetIndex = this.getModelTargetIndex(rowIndex, targetIndex);
@@ -13689,49 +13704,56 @@ class NoderTableComponent extends BaseNoderComponent {
         }
         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;
-                }
+    fillTableRow(rowIndex) {
+        switch (this.table.rows[rowIndex].hRule) {
+            case HRule.AtLeast: {
+                const { rowHeight, hasMerges } = this.getRowHeight(rowIndex);
+                this.tableEl.rows[rowIndex].style.minHeight = `${this.table.rows[rowIndex].height}px`;
+                this.tableEl.rows[rowIndex].style.height = `${rowHeight}px`;
+                this.rowMatrix[rowIndex].height = rowHeight;
+                return hasMerges;
+            }
+            case HRule.Exact:
+                this.tableEl.rows[rowIndex].style.height = `${this.table.rows[rowIndex].height}px`;
+                this.rowMatrix[rowIndex].height = this.table.rows[rowIndex].height;
+                return false;
+            default: {
+                const { rowHeight, hasMerges } = this.getRowHeight(rowIndex);
+                const minRowHeight = this.table.rows[rowIndex].height ?? this.minRowHeight;
+                const resultHeight = minRowHeight > rowHeight ? minRowHeight : rowHeight;
+                this.tableEl.rows[rowIndex].style.height = `${resultHeight}px`;
+                this.rowMatrix[rowIndex].height = resultHeight;
+                return hasMerges;
             }
         }
     }
     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;
+        let rowHeight = 0;
+        let hasMerges = false;
+        this.rowMatrix[rowIndex].cells.forEach((x, index) => {
+            const { height, isMerged } = this.getCellHeight(rowIndex, index, x);
+            hasMerges = hasMerges || isMerged;
+            if (rowHeight < height) {
+                rowHeight = height;
             }
-            return x.cellContentHeight;
         });
-        return Math.max(...cellHeights);
+        return { rowHeight, hasMerges };
+    }
+    getCellHeight(rowIndex, cellIndex, cell) {
+        if (cell.componentRef.instance.cell.verticalMerge === VerticalMerge.Restart) {
+            const isLastVerticalMergedCell = cell.cell !== this.rowMatrix[rowIndex + 1]?.cells[cellIndex].cell;
+            if (isLastVerticalMergedCell) {
+                let i = rowIndex - 1;
+                let currentHeight = cell.cellContentHeight;
+                while (cell.cell === this.rowMatrix[i]?.cells[cellIndex].cell) {
+                    currentHeight -= this.rowMatrix[i].height;
+                    i--;
+                }
+                return { height: currentHeight, isMerged: false };
+            }
+            return { height: 0, isMerged: true };
+        }
+        return { height: cell.cellContentHeight, isMerged: false };
     }
     fillTableCells() {
         for (let i = 0; i < this.rowMatrix.length; i++) {
@@ -13840,12 +13862,6 @@ class NoderTableComponent extends BaseNoderComponent {
     getTableWidth() {
         return this.table.columns.reduce((prev, next) => prev + next.width + this.borderSize, 1);
     }
-    getSplitRowIndex(rowIndex) {
-        return this.getIndexIncludingSplitRows(this.rowMatrix[rowIndex].row);
-    }
-    getIndexIncludingSplitRows(row) {
-        return Array.from(this.tableEl.rows).indexOf(row);
-    }
     getRowsHeightBefore(rowIndex) {
         let index = 0;
         for (const element of this.splits) {
@@ -17137,11 +17153,13 @@ class Editor {
         }
         this.regulatorService.updateCursorPosition();
         this.editorService.setHasSelection(!this.selection.isEmpty);
-        const position = this.mainSession.displayData.positionToIndex(this.selection.selectedRange.start);
-        const pageFormat = this.mainSession.displayData.getPageFormatAtPosition(position);
         const paragraphStyle = this.session.model.paragraphs[this.selection.selectedRange.start.row].paragraphStyle;
         const numbering = this.session.generalProperties.numberings.find(x => x.numberingId === paragraphStyle.numberingId) ?? null;
         this.editorService.paragraphStyle(paragraphStyle, numbering);
+        const position = this.session === this.mainSession
+            ? this.mainSession.displayData.positionToIndex(this.selection.selectedRange.start)
+            : this.regulatorService.getIndexWithinMainSession();
+        const pageFormat = this.mainSession.displayData.getPageFormatAtPosition(position);
         this.editorService.setPageFormat(pageFormat.pageFormatModel);
         this.rerenderMarker();
         this.regulatorService.setSelectedCommentAtCursor();