@talrace/ngx-noder 0.0.2

package/esm2022/lib/+shared/editor/operations/helpers/table-operations.helper.mjs

@@ -0,0 +1,371 @@
+import { CellModel } from '../../../../models/generated/cell.model';
+import { ColumnModel } from '../../../../models/generated/column.model';
+import { DEFAULT_PARAGRAPH_STYLE, DEFAULT_TEXT_STYLE } from '../../core/constants/editor.const';
+import { FormatModel } from '../../../../models/generated/format.model';
+import { IndexedElementOperationsHelper } from './indexed-element-operations.helper';
+import { ParagraphModel } from '../../../../models/generated/paragraph.model';
+import { ParagraphStyleModel } from '../../../../models/generated/paragraph-style.model';
+import { ResizerSide } from '../../custom-components/table/enums/reisizer-side.enum';
+import { RowModel } from '../../../../models/generated/row.model';
+import { TableModel } from '../../../../models/generated/table.model';
+import { TextStyleModel } from '../../../../models/generated/text-style.model';
+import { VerticalMerge } from '../../custom-components/table/enums/vertical-merge.enum';
+export class TableOperationsHelper {
+    static insertContent(tables, insertIndex, tableModel, contentWidth) {
+        let rows = [];
+        for (let i = 0; i < tableModel.rowsCount; i++) {
+            let cells = [];
+            for (let j = 0; j < tableModel.columnsCount; j++) {
+                const cell = new CellModel({
+                    breaks: [],
+                    content: '',
+                    contentLength: 0,
+                    elements: [],
+                    formats: [new FormatModel({ startIndex: 0, endIndex: 0, textStyle: DEFAULT_TEXT_STYLE })],
+                    images: [],
+                    paragraphs: [new ParagraphModel({ insertIndex: 0, paragraphStyle: DEFAULT_PARAGRAPH_STYLE })],
+                    tables: [],
+                    tabs: []
+                });
+                cells.push(cell);
+            }
+            rows.push(new RowModel({ cells: cells }));
+        }
+        const columnWidth = Math.round(contentWidth / tableModel.columnsCount);
+        const columns = [];
+        for (let i = 0; i < tableModel.columnsCount; i++) {
+            const column = new ColumnModel({
+                width: columnWidth
+            });
+            columns.push(column);
+        }
+        const table = new TableModel({ insertIndex: tableModel.insertTableIndex, alignment: 0, rows, columns });
+        IndexedElementOperationsHelper.insertContent(tables, insertIndex, tableModel.content.length);
+        const index = tables.findIndex(x => x.insertIndex > table.insertIndex);
+        if (index < 0) {
+            tables.push(table);
+        }
+        else {
+            tables.splice(index, 0, table);
+        }
+    }
+    static insertTableRows(tables, insertIndex, rowsCount, targetIndex, inheritIndex) {
+        const table = tables.find(x => x.insertIndex === insertIndex);
+        const matrix = this.getMatrix(table);
+        const newCells = this.getNewRowCells(matrix, targetIndex, inheritIndex);
+        this.insertNewRowCells(table, newCells, rowsCount, targetIndex, inheritIndex);
+    }
+    static insertTableColumns(tables, insertIndex, columnsCount, targetIndex, inheritIndex, contentWidth) {
+        const table = tables.find(x => x.insertIndex === insertIndex);
+        const matrix = this.getMatrix(table);
+        const targetIndexes = this.getTargetIndexes(matrix, targetIndex);
+        const newCells = this.getNewColumnCells(matrix, columnsCount, targetIndex, inheritIndex);
+        this.insertNewColumnCells(table, targetIndexes, newCells);
+        this.insertNewColumns(table, columnsCount, targetIndex, inheritIndex);
+        this.calculateColumnsWidth(table, contentWidth);
+    }
+    static removeTableRows(tables, insertIndex, startIndex, endIndex) {
+        const table = tables.find(x => x.insertIndex === insertIndex);
+        const matrix = this.getMatrix(table);
+        this.removeMatrixRows(matrix, startIndex, endIndex);
+        table.rows.splice(startIndex, endIndex - startIndex + 1);
+    }
+    static removeTableColumns(tables, insertIndex, startIndex, endIndex, contentWidth) {
+        const table = tables.find(x => x.insertIndex === insertIndex);
+        const matrix = this.getMatrix(table);
+        table.columns.splice(startIndex, endIndex - startIndex + 1);
+        this.removeMatrixRowCells(matrix, table, startIndex, endIndex);
+        for (let i = 0; i < table.rows.length; i++) {
+            table.rows[i].cells = table.rows[i].cells.filter(x => matrix[i].cells.includes(x));
+        }
+        this.calculateColumnsWidth(table, contentWidth);
+    }
+    static resizeTableColumns(tables, resizeTableColumns) {
+        const table = tables.find(x => x.insertIndex === resizeTableColumns.insertIndex);
+        this.resizeColumns(table, resizeTableColumns);
+        this.calculateCellsWidth(table);
+    }
+    static restoreTable(tables, insertIndex, oldTable) {
+        const table = tables.find(x => x.insertIndex === insertIndex);
+        table.alignment = oldTable.alignment;
+        table.borders = oldTable.borders;
+        table.callSpacing = oldTable.callSpacing;
+        table.columns = oldTable.columns;
+        table.headingStyleId = oldTable.headingStyleId;
+        table.indentLeft = oldTable.indentLeft;
+        table.indentLeftFromText = oldTable.indentLeftFromText;
+        table.indentRightFromText = oldTable.indentRightFromText;
+        table.margins = oldTable.margins;
+        table.rows = oldTable.rows;
+    }
+    static getMatrix(table) {
+        const matrix = [];
+        table.rows.forEach((row, rowIndex) => {
+            matrix.push(new RowModel({ ...row, cells: [] }));
+            row.cells.forEach(cell => {
+                for (let i = 0; i < (cell.horizontalMerge ?? 1); i++) {
+                    matrix[rowIndex].cells.push(cell);
+                }
+            });
+        });
+        return matrix;
+    }
+    static getNewRowCells(matrix, targetIndex, inheritIndex) {
+        const newCells = [];
+        for (let i = 0; i < matrix[inheritIndex].cells.length; i++) {
+            if (matrix[inheritIndex].cells[i] === matrix[inheritIndex].cells[i - 1]) {
+                continue;
+            }
+            const newCell = new CellModel({
+                ...matrix[inheritIndex].cells[i],
+                breaks: [],
+                content: '',
+                contentLength: 0,
+                elements: [],
+                images: [],
+                formats: [
+                    new FormatModel({
+                        startIndex: 0,
+                        endIndex: 0,
+                        textStyle: new TextStyleModel(matrix[inheritIndex].cells[i].formats[0].textStyle)
+                    })
+                ],
+                paragraphs: [
+                    new ParagraphModel({
+                        insertIndex: 0,
+                        paragraphStyle: new ParagraphStyleModel(matrix[inheritIndex].cells[i].paragraphs[0].paragraphStyle)
+                    })
+                ],
+                verticalMerge: this.getCellVerticalMerge(matrix[inheritIndex].cells[i].verticalMerge, targetIndex, inheritIndex),
+                tables: [],
+                tabs: []
+            });
+            newCells.push(newCell);
+        }
+        return newCells;
+    }
+    static getCellVerticalMerge(currentVerticalMerge, targetIndex, inheritIndex) {
+        if (currentVerticalMerge !== VerticalMerge.Restart) {
+            return currentVerticalMerge;
+        }
+        return targetIndex > inheritIndex ? VerticalMerge.Merge : null;
+    }
+    static insertNewRowCells(table, newCells, rowsCount, targetIndex, inheritIndex) {
+        for (let i = 0; i < rowsCount; i++) {
+            const newRowCells = newCells.map(x => new CellModel({
+                ...x,
+                breaks: [],
+                content: '',
+                contentLength: 0,
+                elements: [],
+                formats: [new FormatModel({ startIndex: 0, endIndex: 0, textStyle: new TextStyleModel(x.formats[0].textStyle) })],
+                images: [],
+                paragraphs: [
+                    new ParagraphModel({ insertIndex: 0, paragraphStyle: new ParagraphStyleModel(x.paragraphs[0].paragraphStyle) })
+                ],
+                tables: [],
+                tabs: []
+            }));
+            const newRow = new RowModel({ ...table.rows[inheritIndex], cells: newRowCells });
+            table.rows.splice(targetIndex, 0, newRow);
+        }
+    }
+    static getTargetIndexes(matrix, targetIndex) {
+        const targetIndexes = [];
+        for (const row of matrix) {
+            let absoluteCellIndex = 0;
+            let currentTargetIndex = 0;
+            let cellMatrixIndex = 0;
+            while (absoluteCellIndex < targetIndex) {
+                if (row.cells[cellMatrixIndex] === row.cells[cellMatrixIndex - 1]) {
+                    cellMatrixIndex++;
+                    continue;
+                }
+                if (!row.cells[cellMatrixIndex]) {
+                    break;
+                }
+                absoluteCellIndex += row.cells[cellMatrixIndex].horizontalMerge ?? 1;
+                cellMatrixIndex++;
+                currentTargetIndex++;
+            }
+            targetIndexes.push(currentTargetIndex);
+        }
+        return targetIndexes;
+    }
+    static getNewColumnCells(matrix, columnsCount, targetIndex, inheritIndex) {
+        return matrix.map(row => {
+            const newRowCells = [];
+            const isContinuousCell = inheritIndex === targetIndex
+                ? row.cells[inheritIndex] === row.cells[targetIndex - 1] && row.cells[inheritIndex].horizontalMerge
+                : row.cells[inheritIndex] === row.cells[targetIndex] && row.cells[inheritIndex].horizontalMerge;
+            if (isContinuousCell) {
+                row.cells[inheritIndex].horizontalMerge += columnsCount;
+                return newRowCells;
+            }
+            for (let i = 0; i < columnsCount; i++) {
+                const newCell = new CellModel({
+                    ...row.cells[inheritIndex],
+                    breaks: [],
+                    content: '',
+                    contentLength: 0,
+                    elements: [],
+                    formats: [new FormatModel({ startIndex: 0, endIndex: 0, textStyle: row.cells[inheritIndex].formats[0].textStyle })],
+                    horizontalMerge: null,
+                    images: [],
+                    paragraphs: [
+                        new ParagraphModel({ insertIndex: 0, paragraphStyle: row.cells[inheritIndex].paragraphs[0].paragraphStyle })
+                    ],
+                    tables: [],
+                    tabs: [],
+                    verticalMerge: null,
+                    width: row.cells[inheritIndex].width
+                });
+                newRowCells.push(newCell);
+            }
+            return newRowCells;
+        });
+    }
+    static insertNewColumnCells(table, targetIndexes, newCells) {
+        for (let i = 0; i < targetIndexes.length; i++) {
+            if (!newCells[i].length) {
+                continue;
+            }
+            table.rows[i].cells.splice(targetIndexes[i], 0, ...newCells[i]);
+        }
+    }
+    static insertNewColumns(table, columnsCount, targetIndex, inheritIndex) {
+        const newColumn = table.columns[inheritIndex];
+        for (let i = 0; i < columnsCount; i++) {
+            table.columns.splice(targetIndex, 0, new ColumnModel(newColumn));
+        }
+    }
+    static calculateColumnsWidth(table, contentWidth) {
+        let currentTableWidth = table.columns.reduce((prev, next) => prev + next.width, 0);
+        table.columns.forEach(x => (x.width = Math.round((x.width / currentTableWidth) * contentWidth)));
+        table.rows.forEach(row => {
+            for (let i = 0; i < row.cells.length; i++) {
+                if (row.cells[i].horizontalMerge) {
+                    let width = table.columns[i].width;
+                    for (let j = 1; j < row.cells[i].horizontalMerge; j++) {
+                        width += table.columns[i + j].width;
+                    }
+                    row.cells[i].width = width;
+                }
+                else {
+                    row.cells[i].width = table.columns[i].width;
+                }
+            }
+        });
+    }
+    static removeMatrixRows(matrix, startIndex, endIndex) {
+        const removedRows = matrix.slice(startIndex, endIndex + 1);
+        matrix.splice(startIndex, endIndex - startIndex + 1);
+        let i = 0;
+        while (i < matrix.length) {
+            let j = 0;
+            while (j < matrix[i].cells.length) {
+                if (matrix[i].cells[j].verticalMerge === VerticalMerge.Restart &&
+                    (!matrix[i + 1] || matrix[i].cells[j].verticalMerge !== VerticalMerge.Merge)) {
+                    matrix[i].cells[j].verticalMerge = null;
+                }
+                if (matrix[i].cells[j].verticalMerge === VerticalMerge.Merge &&
+                    ![VerticalMerge.Restart, VerticalMerge.Merge].includes(matrix[i - 1]?.cells[j].verticalMerge)) {
+                    this.fillMergedCellAfterRemove(matrix, removedRows, i, j);
+                }
+                j++;
+            }
+            i++;
+        }
+    }
+    static fillMergedCellAfterRemove(matrix, removedRows, rowIndex, cellIndex) {
+        let i = removedRows.length - 1;
+        let removedCell;
+        while (!removedCell) {
+            if (removedRows[i].cells[cellIndex].verticalMerge === VerticalMerge.Restart) {
+                removedCell = removedRows[i].cells[cellIndex];
+            }
+            i--;
+        }
+        matrix[rowIndex].cells[cellIndex].backgroundColor = removedCell.backgroundColor;
+        matrix[rowIndex].cells[cellIndex].borders = removedCell.borders;
+        matrix[rowIndex].cells[cellIndex].breaks = removedCell.breaks;
+        matrix[rowIndex].cells[cellIndex].columnSections = removedCell.columnSections;
+        matrix[rowIndex].cells[cellIndex].content = removedCell.content;
+        matrix[rowIndex].cells[cellIndex].contentLength = removedCell.contentLength;
+        matrix[rowIndex].cells[cellIndex].elements = removedCell.elements;
+        matrix[rowIndex].cells[cellIndex].formats = removedCell.formats;
+        matrix[rowIndex].cells[cellIndex].horizontalMerge = removedCell.horizontalMerge;
+        matrix[rowIndex].cells[cellIndex].images = removedCell.images;
+        matrix[rowIndex].cells[cellIndex].margins = removedCell.margins;
+        matrix[rowIndex].cells[cellIndex].paragraphs = removedCell.paragraphs;
+        matrix[rowIndex].cells[cellIndex].tables = removedCell.tables;
+        matrix[rowIndex].cells[cellIndex].verticalAlign = removedCell.verticalAlign;
+        matrix[rowIndex].cells[cellIndex].verticalMerge = removedCell.verticalMerge;
+        matrix[rowIndex].cells[cellIndex].width = removedCell.width;
+    }
+    static removeMatrixRowCells(matrix, table, startIndex, endIndex) {
+        let i = 0;
+        while (i < matrix.length) {
+            let j = 0;
+            matrix[i].cells.splice(startIndex, endIndex - startIndex + 1);
+            while (j < matrix[i].cells.length) {
+                if (matrix[i].cells[j].horizontalMerge > 1) {
+                    const mergedCellsCount = this.fillDataForHorizontalMergedCell(matrix, table, i, j);
+                    j += mergedCellsCount;
+                }
+                else {
+                    j++;
+                }
+            }
+            i++;
+        }
+    }
+    static fillDataForHorizontalMergedCell(matrix, table, rowIndex, cellIndex) {
+        const mergedCells = matrix[rowIndex].cells.filter(x => x === matrix[rowIndex].cells[cellIndex]);
+        if (mergedCells.length > 1) {
+            matrix[rowIndex].cells[cellIndex].horizontalMerge = mergedCells.length;
+            matrix[rowIndex].cells[cellIndex].width = 0;
+            for (let i = 0; i < matrix[rowIndex].cells[cellIndex].horizontalMerge; i++) {
+                matrix[rowIndex].cells[cellIndex].width += table.columns[cellIndex + i].width;
+            }
+        }
+        else {
+            matrix[rowIndex].cells[cellIndex].horizontalMerge = null;
+            matrix[rowIndex].cells[cellIndex].width = table.columns[cellIndex].width;
+        }
+        matrix[rowIndex].cells[cellIndex].horizontalMerge = mergedCells.length > 1 ? mergedCells.length : null;
+        return mergedCells.length;
+    }
+    static resizeColumns(table, resizeTableColumns) {
+        if (resizeTableColumns.resizerSide === ResizerSide.Left) {
+            table.columns[resizeTableColumns.columnIndex].width += resizeTableColumns.distance;
+            return;
+        }
+        const cellHorizontalMerge = table.rows[resizeTableColumns.rowIndex].cells[resizeTableColumns.cellIndex].horizontalMerge ?? 1;
+        const resizerColumnIndex = resizeTableColumns.columnIndex + cellHorizontalMerge - 1;
+        table.columns[resizerColumnIndex].width += resizeTableColumns.distance;
+        if (table.rows[resizeTableColumns.rowIndex].cells[resizeTableColumns.cellIndex + 1]) {
+            table.columns[resizerColumnIndex + 1].width -= resizeTableColumns.distance;
+        }
+    }
+    static calculateCellsWidth(table) {
+        table.rows.forEach(row => {
+            let columnIndex = 0;
+            for (let i = 0; i < row.cells.length; i++) {
+                if (row.cells[i].horizontalMerge) {
+                    let width = table.columns[columnIndex].width;
+                    for (let j = 1; j < row.cells[i].horizontalMerge; j++) {
+                        width += table.columns[columnIndex + j].width;
+                    }
+                    row.cells[i].width = width;
+                    columnIndex += row.cells[i].horizontalMerge;
+                }
+                else {
+                    row.cells[i].width = table.columns[columnIndex].width;
+                    columnIndex++;
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-operations.helper.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-noder/src/lib/+shared/editor/operations/helpers/table-operations.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { CellModel } from '../../../../models/generated/cell.model';\nimport { ColumnModel } from '../../../../models/generated/column.model';\nimport { DEFAULT_PARAGRAPH_STYLE, DEFAULT_TEXT_STYLE } from '../../core/constants/editor.const';\nimport { FormatModel } from '../../../../models/generated/format.model';\nimport { IndexedElementOperationsHelper } from './indexed-element-operations.helper';\nimport { InsertTableModel } from '../../../../models/generated/insert-table.model';\nimport { ParagraphModel } from '../../../../models/generated/paragraph.model';\nimport { ParagraphStyleModel } from '../../../../models/generated/paragraph-style.model';\nimport { ResizeTableColumnsModel } from '../../../../models/generated/resize-table-columns.model';\nimport { ResizerSide } from '../../custom-components/table/enums/reisizer-side.enum';\nimport { RowModel } from '../../../../models/generated/row.model';\nimport { TableModel } from '../../../../models/generated/table.model';\nimport { TextStyleModel } from '../../../../models/generated/text-style.model';\nimport { VerticalMerge } from '../../custom-components/table/enums/vertical-merge.enum';\n\nexport class TableOperationsHelper {\n    static insertContent(tables: TableModel[], insertIndex: number, tableModel: InsertTableModel, contentWidth: number): void {\n        let rows: RowModel[] = [];\n        for (let i = 0; i < tableModel.rowsCount; i++) {\n            let cells: CellModel[] = [];\n            for (let j = 0; j < tableModel.columnsCount; j++) {\n                const cell = new CellModel({\n                    breaks: [],\n                    content: '',\n                    contentLength: 0,\n                    elements: [],\n                    formats: [new FormatModel({ startIndex: 0, endIndex: 0, textStyle: DEFAULT_TEXT_STYLE })],\n                    images: [],\n                    paragraphs: [new ParagraphModel({ insertIndex: 0, paragraphStyle: DEFAULT_PARAGRAPH_STYLE })],\n                    tables: [],\n                    tabs: []\n                });\n                cells.push(cell);\n            }\n\n            rows.push(new RowModel({ cells: cells }));\n        }\n\n        const columnWidth = Math.round(contentWidth / tableModel.columnsCount);\n        const columns = [];\n        for (let i = 0; i < tableModel.columnsCount; i++) {\n            const column = new ColumnModel({\n                width: columnWidth\n            });\n            columns.push(column);\n        }\n        const table = new TableModel({ insertIndex: tableModel.insertTableIndex, alignment: 0, rows, columns });\n\n        IndexedElementOperationsHelper.insertContent(tables, insertIndex, tableModel.content.length);\n        const index = tables.findIndex(x => x.insertIndex > table.insertIndex);\n        if (index < 0) {\n            tables.push(table);\n        } else {\n            tables.splice(index, 0, table);\n        }\n    }\n    static insertTableRows(tables: TableModel[], insertIndex: number, rowsCount: number, targetIndex: number, inheritIndex: number): void {\n        const table = tables.find(x => x.insertIndex === insertIndex);\n        const matrix = this.getMatrix(table);\n        const newCells = this.getNewRowCells(matrix, targetIndex, inheritIndex);\n        this.insertNewRowCells(table, newCells, rowsCount, targetIndex, inheritIndex);\n    }\n\n    static insertTableColumns(\n        tables: TableModel[],\n        insertIndex: number,\n        columnsCount: number,\n        targetIndex: number,\n        inheritIndex: number,\n        contentWidth: number\n    ): void {\n        const table = tables.find(x => x.insertIndex === insertIndex);\n        const matrix = this.getMatrix(table);\n        const targetIndexes = this.getTargetIndexes(matrix, targetIndex);\n        const newCells = this.getNewColumnCells(matrix, columnsCount, targetIndex, inheritIndex);\n        this.insertNewColumnCells(table, targetIndexes, newCells);\n        this.insertNewColumns(table, columnsCount, targetIndex, inheritIndex);\n        this.calculateColumnsWidth(table, contentWidth);\n    }\n\n    static removeTableRows(tables: TableModel[], insertIndex: number, startIndex: number, endIndex: number): void {\n        const table = tables.find(x => x.insertIndex === insertIndex);\n        const matrix = this.getMatrix(table);\n        this.removeMatrixRows(matrix, startIndex, endIndex);\n        table.rows.splice(startIndex, endIndex - startIndex + 1);\n    }\n\n    static removeTableColumns(tables: TableModel[], insertIndex: number, startIndex: number, endIndex: number, contentWidth: number): void {\n        const table = tables.find(x => x.insertIndex === insertIndex);\n        const matrix = this.getMatrix(table);\n        table.columns.splice(startIndex, endIndex - startIndex + 1);\n        this.removeMatrixRowCells(matrix, table, startIndex, endIndex);\n        for (let i = 0; i < table.rows.length; i++) {\n            table.rows[i].cells = table.rows[i].cells.filter(x => matrix[i].cells.includes(x));\n        }\n\n        this.calculateColumnsWidth(table, contentWidth);\n    }\n\n    static resizeTableColumns(tables: TableModel[], resizeTableColumns: ResizeTableColumnsModel): void {\n        const table = tables.find(x => x.insertIndex === resizeTableColumns.insertIndex);\n        this.resizeColumns(table, resizeTableColumns);\n        this.calculateCellsWidth(table);\n    }\n\n    static restoreTable(tables: TableModel[], insertIndex: number, oldTable: TableModel): void {\n        const table = tables.find(x => x.insertIndex === insertIndex);\n        table.alignment = oldTable.alignment;\n        table.borders = oldTable.borders;\n        table.callSpacing = oldTable.callSpacing;\n        table.columns = oldTable.columns;\n        table.headingStyleId = oldTable.headingStyleId;\n        table.indentLeft = oldTable.indentLeft;\n        table.indentLeftFromText = oldTable.indentLeftFromText;\n        table.indentRightFromText = oldTable.indentRightFromText;\n        table.margins = oldTable.margins;\n        table.rows = oldTable.rows;\n    }\n\n    static getMatrix(table: TableModel): RowModel[] {\n        const matrix: RowModel[] = [];\n\n        table.rows.forEach((row, rowIndex) => {\n            matrix.push(new RowModel({ ...row, cells: [] }));\n\n            row.cells.forEach(cell => {\n                for (let i = 0; i < (cell.horizontalMerge ?? 1); i++) {\n                    matrix[rowIndex].cells.push(cell);\n                }\n            });\n        });\n\n        return matrix;\n    }\n\n    static getNewRowCells(matrix: RowModel[], targetIndex: number, inheritIndex: number): CellModel[] {\n        const newCells: CellModel[] = [];\n\n        for (let i = 0; i < matrix[inheritIndex].cells.length; i++) {\n            if (matrix[inheritIndex].cells[i] === matrix[inheritIndex].cells[i - 1]) {\n                continue;\n            }\n\n            const newCell = new CellModel({\n                ...matrix[inheritIndex].cells[i],\n                breaks: [],\n                content: '',\n                contentLength: 0,\n                elements: [],\n                images: [],\n                formats: [\n                    new FormatModel({\n                        startIndex: 0,\n                        endIndex: 0,\n                        textStyle: new TextStyleModel(matrix[inheritIndex].cells[i].formats[0].textStyle)\n                    })\n                ],\n                paragraphs: [\n                    new ParagraphModel({\n                        insertIndex: 0,\n                        paragraphStyle: new ParagraphStyleModel(matrix[inheritIndex].cells[i].paragraphs[0].paragraphStyle)\n                    })\n                ],\n                verticalMerge: this.getCellVerticalMerge(\n                    matrix[inheritIndex].cells[i].verticalMerge as VerticalMerge,\n                    targetIndex,\n                    inheritIndex\n                ),\n                tables: [],\n                tabs: []\n            });\n            newCells.push(newCell);\n        }\n\n        return newCells;\n    }\n\n    static getCellVerticalMerge(currentVerticalMerge: VerticalMerge, targetIndex: number, inheritIndex: number): string | null {\n        if (currentVerticalMerge !== VerticalMerge.Restart) {\n            return currentVerticalMerge;\n        }\n\n        return targetIndex > inheritIndex ? VerticalMerge.Merge : null;\n    }\n\n    static insertNewRowCells(table: TableModel, newCells: CellModel[], rowsCount: number, targetIndex: number, inheritIndex: number): void {\n        for (let i = 0; i < rowsCount; i++) {\n            const newRowCells = newCells.map(\n                x =>\n                    new CellModel({\n                        ...x,\n                        breaks: [],\n                        content: '',\n                        contentLength: 0,\n                        elements: [],\n                        formats: [new FormatModel({ startIndex: 0, endIndex: 0, textStyle: new TextStyleModel(x.formats[0].textStyle) })],\n                        images: [],\n                        paragraphs: [\n                            new ParagraphModel({ insertIndex: 0, paragraphStyle: new ParagraphStyleModel(x.paragraphs[0].paragraphStyle) })\n                        ],\n                        tables: [],\n                        tabs: []\n                    })\n            );\n            const newRow = new RowModel({ ...table.rows[inheritIndex], cells: newRowCells });\n            table.rows.splice(targetIndex, 0, newRow);\n        }\n    }\n\n    static getTargetIndexes(matrix: RowModel[], targetIndex: number): number[] {\n        const targetIndexes: number[] = [];\n\n        for (const row of matrix) {\n            let absoluteCellIndex = 0;\n            let currentTargetIndex = 0;\n            let cellMatrixIndex = 0;\n\n            while (absoluteCellIndex < targetIndex) {\n                if (row.cells[cellMatrixIndex] === row.cells[cellMatrixIndex - 1]) {\n                    cellMatrixIndex++;\n                    continue;\n                }\n\n                if (!row.cells[cellMatrixIndex]) {\n                    break;\n                }\n\n                absoluteCellIndex += row.cells[cellMatrixIndex].horizontalMerge ?? 1;\n                cellMatrixIndex++;\n                currentTargetIndex++;\n            }\n\n            targetIndexes.push(currentTargetIndex);\n        }\n\n        return targetIndexes;\n    }\n\n    static getNewColumnCells(matrix: RowModel[], columnsCount: number, targetIndex: number, inheritIndex: number): CellModel[][] {\n        return matrix.map(row => {\n            const newRowCells: CellModel[] = [];\n            const isContinuousCell =\n                inheritIndex === targetIndex\n                    ? row.cells[inheritIndex] === row.cells[targetIndex - 1] && row.cells[inheritIndex].horizontalMerge\n                    : row.cells[inheritIndex] === row.cells[targetIndex] && row.cells[inheritIndex].horizontalMerge;\n\n            if (isContinuousCell) {\n                row.cells[inheritIndex].horizontalMerge += columnsCount;\n                return newRowCells;\n            }\n\n            for (let i = 0; i < columnsCount; i++) {\n                const newCell = new CellModel({\n                    ...row.cells[inheritIndex],\n                    breaks: [],\n                    content: '',\n                    contentLength: 0,\n                    elements: [],\n                    formats: [new FormatModel({ startIndex: 0, endIndex: 0, textStyle: row.cells[inheritIndex].formats[0].textStyle })],\n                    horizontalMerge: null,\n                    images: [],\n                    paragraphs: [\n                        new ParagraphModel({ insertIndex: 0, paragraphStyle: row.cells[inheritIndex].paragraphs[0].paragraphStyle })\n                    ],\n                    tables: [],\n                    tabs: [],\n                    verticalMerge: null,\n                    width: row.cells[inheritIndex].width\n                });\n\n                newRowCells.push(newCell);\n            }\n\n            return newRowCells;\n        });\n    }\n\n    static insertNewColumnCells(table: TableModel, targetIndexes: number[], newCells: CellModel[][]): void {\n        for (let i = 0; i < targetIndexes.length; i++) {\n            if (!newCells[i].length) {\n                continue;\n            }\n\n            table.rows[i].cells.splice(targetIndexes[i], 0, ...newCells[i]);\n        }\n    }\n\n    static insertNewColumns(table: TableModel, columnsCount: number, targetIndex: number, inheritIndex: number): void {\n        const newColumn = table.columns[inheritIndex];\n        for (let i = 0; i < columnsCount; i++) {\n            table.columns.splice(targetIndex, 0, new ColumnModel(newColumn));\n        }\n    }\n\n    static calculateColumnsWidth(table: TableModel, contentWidth: number): void {\n        let currentTableWidth = table.columns.reduce((prev, next) => prev + next.width, 0);\n        table.columns.forEach(x => (x.width = Math.round((x.width / currentTableWidth) * contentWidth)));\n\n        table.rows.forEach(row => {\n            for (let i = 0; i < row.cells.length; i++) {\n                if (row.cells[i].horizontalMerge) {\n                    let width = table.columns[i].width;\n\n                    for (let j = 1; j < row.cells[i].horizontalMerge; j++) {\n                        width += table.columns[i + j].width;\n                    }\n\n                    row.cells[i].width = width;\n                } else {\n                    row.cells[i].width = table.columns[i].width;\n                }\n            }\n        });\n    }\n\n    static removeMatrixRows(matrix: RowModel[], startIndex: number, endIndex: number): void {\n        const removedRows = matrix.slice(startIndex, endIndex + 1);\n        matrix.splice(startIndex, endIndex - startIndex + 1);\n        let i = 0;\n\n        while (i < matrix.length) {\n            let j = 0;\n\n            while (j < matrix[i].cells.length) {\n                if (\n                    (matrix[i].cells[j].verticalMerge as VerticalMerge) === VerticalMerge.Restart &&\n                    (!matrix[i + 1] || (matrix[i].cells[j].verticalMerge as VerticalMerge) !== VerticalMerge.Merge)\n                ) {\n                    matrix[i].cells[j].verticalMerge = null;\n                }\n\n                if (\n                    (matrix[i].cells[j].verticalMerge as VerticalMerge) === VerticalMerge.Merge &&\n                    ![VerticalMerge.Restart, VerticalMerge.Merge].includes(matrix[i - 1]?.cells[j].verticalMerge as VerticalMerge)\n                ) {\n                    this.fillMergedCellAfterRemove(matrix, removedRows, i, j);\n                }\n\n                j++;\n            }\n\n            i++;\n        }\n    }\n\n    static fillMergedCellAfterRemove(matrix: RowModel[], removedRows: RowModel[], rowIndex: number, cellIndex: number): void {\n        let i = removedRows.length - 1;\n        let removedCell: CellModel;\n\n        while (!removedCell) {\n            if ((removedRows[i].cells[cellIndex].verticalMerge as VerticalMerge) === VerticalMerge.Restart) {\n                removedCell = removedRows[i].cells[cellIndex];\n            }\n\n            i--;\n        }\n\n        matrix[rowIndex].cells[cellIndex].backgroundColor = removedCell.backgroundColor;\n        matrix[rowIndex].cells[cellIndex].borders = removedCell.borders;\n        matrix[rowIndex].cells[cellIndex].breaks = removedCell.breaks;\n        matrix[rowIndex].cells[cellIndex].columnSections = removedCell.columnSections;\n        matrix[rowIndex].cells[cellIndex].content = removedCell.content;\n        matrix[rowIndex].cells[cellIndex].contentLength = removedCell.contentLength;\n        matrix[rowIndex].cells[cellIndex].elements = removedCell.elements;\n        matrix[rowIndex].cells[cellIndex].formats = removedCell.formats;\n        matrix[rowIndex].cells[cellIndex].horizontalMerge = removedCell.horizontalMerge;\n        matrix[rowIndex].cells[cellIndex].images = removedCell.images;\n        matrix[rowIndex].cells[cellIndex].margins = removedCell.margins;\n        matrix[rowIndex].cells[cellIndex].paragraphs = removedCell.paragraphs;\n        matrix[rowIndex].cells[cellIndex].tables = removedCell.tables;\n        matrix[rowIndex].cells[cellIndex].verticalAlign = removedCell.verticalAlign;\n        matrix[rowIndex].cells[cellIndex].verticalMerge = removedCell.verticalMerge;\n        matrix[rowIndex].cells[cellIndex].width = removedCell.width;\n    }\n\n    static removeMatrixRowCells(matrix: RowModel[], table: TableModel, startIndex: number, endIndex: number): void {\n        let i = 0;\n\n        while (i < matrix.length) {\n            let j = 0;\n            matrix[i].cells.splice(startIndex, endIndex - startIndex + 1);\n\n            while (j < matrix[i].cells.length) {\n                if (matrix[i].cells[j].horizontalMerge > 1) {\n                    const mergedCellsCount = this.fillDataForHorizontalMergedCell(matrix, table, i, j);\n                    j += mergedCellsCount;\n                } else {\n                    j++;\n                }\n            }\n\n            i++;\n        }\n    }\n\n    static fillDataForHorizontalMergedCell(matrix: RowModel[], table: TableModel, rowIndex: number, cellIndex: number): number {\n        const mergedCells = matrix[rowIndex].cells.filter(x => x === matrix[rowIndex].cells[cellIndex]);\n\n        if (mergedCells.length > 1) {\n            matrix[rowIndex].cells[cellIndex].horizontalMerge = mergedCells.length;\n            matrix[rowIndex].cells[cellIndex].width = 0;\n\n            for (let i = 0; i < matrix[rowIndex].cells[cellIndex].horizontalMerge; i++) {\n                matrix[rowIndex].cells[cellIndex].width += table.columns[cellIndex + i].width;\n            }\n        } else {\n            matrix[rowIndex].cells[cellIndex].horizontalMerge = null;\n            matrix[rowIndex].cells[cellIndex].width = table.columns[cellIndex].width;\n        }\n\n        matrix[rowIndex].cells[cellIndex].horizontalMerge = mergedCells.length > 1 ? mergedCells.length : null;\n        return mergedCells.length;\n    }\n\n    static resizeColumns(table: TableModel, resizeTableColumns: ResizeTableColumnsModel): void {\n        if (resizeTableColumns.resizerSide === ResizerSide.Left) {\n            table.columns[resizeTableColumns.columnIndex].width += resizeTableColumns.distance;\n            return;\n        }\n\n        const cellHorizontalMerge = table.rows[resizeTableColumns.rowIndex].cells[resizeTableColumns.cellIndex].horizontalMerge ?? 1;\n        const resizerColumnIndex = resizeTableColumns.columnIndex + cellHorizontalMerge - 1;\n        table.columns[resizerColumnIndex].width += resizeTableColumns.distance;\n\n        if (table.rows[resizeTableColumns.rowIndex].cells[resizeTableColumns.cellIndex + 1]) {\n            table.columns[resizerColumnIndex + 1].width -= resizeTableColumns.distance;\n        }\n    }\n\n    static calculateCellsWidth(table: TableModel): void {\n        table.rows.forEach(row => {\n            let columnIndex = 0;\n            for (let i = 0; i < row.cells.length; i++) {\n                if (row.cells[i].horizontalMerge) {\n                    let width = table.columns[columnIndex].width;\n\n                    for (let j = 1; j < row.cells[i].horizontalMerge; j++) {\n                        width += table.columns[columnIndex + j].width;\n                    }\n\n                    row.cells[i].width = width;\n                    columnIndex += row.cells[i].horizontalMerge;\n                } else {\n                    row.cells[i].width = table.columns[columnIndex].width;\n                    columnIndex++;\n                }\n            }\n        });\n    }\n}\n"]}

package/esm2022/lib/+shared/editor/operations/helpers/target-operations.helper.mjs

@@ -0,0 +1,23 @@
+import { EdgeType } from '../../core/components/edges/edge-type.enum';
+import { TargetType } from '../enums/target-type.enum';
+export class TargetOperationsHelper {
+    static getContents(contents, target, document) {
+        switch (target.type) {
+            case TargetType.Document:
+                return contents;
+            case TargetType.TableCell: {
+                const cellTarget = target.tableCell;
+                const table = contents.tables.find(x => x.insertIndex === cellTarget.insertIndex);
+                return table.rows[cellTarget.row].cells[cellTarget.column];
+            }
+            case TargetType.Edge: {
+                const edgeTarget = target.edgeData;
+                const edges = edgeTarget.type === EdgeType.Header ? document.headers : document.footers;
+                return edges.find(x => x.pageType === edgeTarget.pageType);
+            }
+            default:
+                throw new Error('Invalid target type for operation');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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