@contrail/document-table 1.0.1

package/lib/table-paste.service.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TablePasteService = void 0;
+const documents_1 = require("@contrail/documents");
+const util_1 = require("@contrail/util");
+const table_merge_service_1 = require("./table-merge.service");
+const table_service_1 = require("./table.service");
+const table_range_1 = require("./table-range");
+class TablePasteService {
+    constructor() { }
+    static log(...message) {
+        this.isDebug && console.log(...message);
+    }
+    static pasteRowsAndColumns(tableElement, childElements, elementsToPaste, targetRow, targetColumn) {
+        var _a, _b, _c;
+        const tableToPaste = elementsToPaste.find(e => e.type === 'table');
+        const rowsToPaste = elementsToPaste.filter(e => e.type === 'row');
+        const columnsToPaste = elementsToPaste.filter(e => e.type === 'column');
+        const cellsToPaste = elementsToPaste.filter(e => e.type === 'cell');
+        const startRow = targetRow;
+        const endRow = startRow + tableToPaste.rowIds.length - 1;
+        const startColumn = targetColumn;
+        const endColumn = startColumn + tableToPaste.columnIds.length - 1;
+        const existingCells = childElements.filter(e => e.type === 'cell');
+        const elementsToCreate = [];
+        const elementsToUpdate = [];
+        let existingMergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableElement, childElements);
+        for (let rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
+            const rowToPaste = rowsToPaste[rowIndex - targetRow];
+            let existingRowId = tableElement.rowIds[rowIndex];
+            let existingRow = childElements.find(e => e.type === 'row' && e.id === existingRowId) ||
+                elementsToCreate.find(e => e.type === 'row' && e.id === existingRowId);
+            this.log('current row', rowIndex, existingRowId, existingRow);
+            if (!existingRowId) {
+                const [newRow, ...newRowCells] = (_a = table_service_1.TableService.addRow(tableElement, [...existingCells, ...elementsToCreate], rowIndex, rowToPaste.size.height)) === null || _a === void 0 ? void 0 : _a.elementsToCreate;
+                elementsToCreate.push(newRow, ...newRowCells);
+                existingRowId = newRow.id;
+                existingRow = newRow;
+                this.log('added row', rowIndex, existingRowId, existingRow);
+            }
+            if (rowToPaste.size.height > existingRow.size.height) {
+                this.log('resized row', rowIndex, existingRowId, existingRow);
+                elementsToUpdate.push(table_service_1.TableService.resizeRow(tableElement, childElements, existingRowId, rowToPaste.size.height)
+                    .elementsToUpdate[1]);
+            }
+            for (let columnIndex = startColumn; columnIndex <= endColumn; columnIndex++) {
+                const columnToPaste = columnsToPaste[columnIndex - targetColumn];
+                let existingColumnId = tableElement.columnIds[columnIndex];
+                let existingColumn = childElements.find(e => e.type === 'column' && e.id === existingColumnId) ||
+                    elementsToCreate.find(e => e.type === 'column' && e.id === existingColumnId);
+                this.log('current column', columnIndex, existingColumnId, existingColumn);
+                if (!tableElement.columnIds[columnIndex]) {
+                    const [newColumn, ...newColumnCells] = (_b = table_service_1.TableService.addColumn(tableElement, [...existingCells, ...elementsToCreate], columnIndex, columnToPaste.size.width)) === null || _b === void 0 ? void 0 : _b.elementsToCreate;
+                    elementsToCreate.push(newColumn, ...newColumnCells);
+                    existingColumnId = newColumn.id;
+                    existingColumn = newColumn;
+                    this.log('added column', columnIndex, existingColumnId, existingColumn);
+                }
+                if (columnToPaste.size.width > existingColumn.size.width) {
+                    const updatedColumn = table_service_1.TableService.resizeColumn(tableElement, childElements, existingColumnId, columnToPaste.size.width).elementsToUpdate[1];
+                    const updatedRowAndCells = table_service_1.TableService.autoFitRows(tableElement, childElements, existingColumnId)
+                        .elementsToUpdate;
+                    const uniqueUpdatedRowAndCells = (0, documents_1.uniqueElementsToUpdate)(updatedRowAndCells, elementsToUpdate);
+                    elementsToUpdate.push(updatedColumn);
+                    elementsToUpdate.push(...uniqueUpdatedRowAndCells);
+                    this.log('resized column', columnIndex, existingColumnId, existingColumn);
+                    this.log('resized column cells and row', uniqueUpdatedRowAndCells, uniqueUpdatedRowAndCells);
+                }
+                const cellToPaste = cellsToPaste.find(e => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
+                if (!cellToPaste)
+                    continue;
+                const cellRange = new table_range_1.TableRange(rowIndex, rowIndex, columnIndex, columnIndex);
+                const mergedRange = existingMergedRanges.find(range => range.intersects(cellRange));
+                const mergedRangeOther = mergedRange && !cellRange.equals(mergedRange.start());
+                if (mergedRange) {
+                    existingMergedRanges = existingMergedRanges.filter(r => !r.equals(mergedRange));
+                }
+                if (mergedRangeOther) {
+                    const [updatedTable, ...unmergedCellAndRow] = (_c = table_merge_service_1.TableMergeService.unmerge(tableElement, childElements, mergedRange)) === null || _c === void 0 ? void 0 : _c.elementsToUpdate;
+                    const uniqueUnmergedCellAndRow = (0, documents_1.uniqueElementsToUpdate)(unmergedCellAndRow, elementsToUpdate);
+                    elementsToUpdate.push(...uniqueUnmergedCellAndRow);
+                    this.log('unmerged', mergedRange, unmergedCellAndRow, uniqueUnmergedCellAndRow);
+                }
+            }
+        }
+        return { elementsToCreate, elementsToUpdate };
+    }
+    static pasteTableCells(tableElement, childElements, elementsToPaste, targetRow, targetColumn) {
+        const tableToPaste = elementsToPaste.find(e => e.type === 'table');
+        const rowsToPaste = elementsToPaste.filter(e => e.type === 'row');
+        const columnsToPaste = elementsToPaste.filter(e => e.type === 'column');
+        const cellsToPaste = elementsToPaste.filter(e => e.type === 'cell');
+        const startRow = targetRow;
+        const endRow = startRow + tableToPaste.rowIds.length - 1;
+        const startColumn = targetColumn;
+        const endColumn = startColumn + tableToPaste.columnIds.length - 1;
+        const existingCells = childElements.filter(e => e.type === 'cell');
+        const tableUndo = util_1.ObjectUtil.cloneDeep(tableElement);
+        const { elementsToUpdate, elementsToCreate } = TablePasteService.pasteRowsAndColumns(tableElement, childElements, elementsToPaste, targetRow, targetColumn);
+        for (let rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
+            const rowToPaste = rowsToPaste[rowIndex - targetRow];
+            const existingRowId = tableElement.rowIds[rowIndex];
+            for (let columnIndex = startColumn; columnIndex <= endColumn; columnIndex++) {
+                const columnToPaste = columnsToPaste[columnIndex - targetColumn];
+                const existingColumnId = tableElement.columnIds[columnIndex];
+                const existingColumn = childElements.find(e => e.type === 'column' && e.id === existingColumnId) ||
+                    elementsToCreate.find(e => e.type === 'column' && e.id === existingColumnId);
+                const cellToPaste = cellsToPaste.find(e => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
+                if (!cellToPaste)
+                    continue;
+                const createdCell = elementsToCreate.find(e => e.type === 'cell' && e.rowId === existingRowId && e.columnId === existingColumnId);
+                const existingCell = existingCells.find(e => e.rowId === existingRowId && e.columnId === existingColumnId);
+                const cell = createdCell !== null && createdCell !== void 0 ? createdCell : existingCell;
+                const cellUndo = util_1.ObjectUtil.cloneDeep(cell);
+                this.log('cell to paste', cellToPaste);
+                this.log('pasting to', cell, cellUndo, createdCell);
+                cell.text = cellToPaste.text;
+                cell.style = util_1.ObjectUtil.mergeDeep(util_1.ObjectUtil.cloneDeep(table_service_1.TableService.DEFAULT_CELL_STYLE), util_1.ObjectUtil.cloneDeep(cellToPaste.style));
+                cell.colspan = cellToPaste.colspan > 1 ? cellToPaste.colspan : 1;
+                cell.rowspan = cellToPaste.rowspan > 1 ? cellToPaste.rowspan : 1;
+                const cellMergedRanged = table_merge_service_1.TableMergeService.getMergedRange(tableElement, cell);
+                cell.size.width = cellMergedRanged
+                    ? table_service_1.TableService.getColumnsWidth(tableElement, [...childElements, ...elementsToCreate], cellMergedRanged.startColumn, cellMergedRanged.endColumn)
+                    : existingColumn.size.width;
+                cell.size.height = table_service_1.TableService.getCellSize(cell).height;
+                if (!createdCell && !elementsToUpdate.find(({ change }) => change.id === cell.id)) {
+                    cellUndo.colspan = cellUndo.colspan > 1 ? cellUndo.colspan : 1;
+                    cellUndo.rowspan = cellUndo.rowspan > 1 ? cellUndo.rowspan : 1;
+                    elementsToUpdate.push({
+                        change: cell,
+                        undo: cellUndo,
+                    });
+                }
+            }
+        }
+        elementsToUpdate.push({
+            change: tableElement,
+            undo: tableUndo,
+        });
+        return {
+            elementsToUpdate,
+            elementsToCreate,
+        };
+    }
+}
+exports.TablePasteService = TablePasteService;
+TablePasteService.isDebug = false;

package/lib/table-range.d.ts

@@ -0,0 +1,33 @@
+export declare class TableRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+    constructor(startRow: number, endRow: number, startColumn: number, endColumn: number);
+    start(): TableRange;
+    get rows(): number;
+    get cols(): number;
+    singular(): boolean;
+    isStart(rowIndex: number, columnIndex: number): boolean;
+    eachRow(cb: (index: number) => void, max?: number): TableRange;
+    eachColumn(cb: (index: number) => void, max?: number): TableRange;
+    each(cb: (rowIndex: number, columnIndex: number) => void): TableRange;
+    union(other: TableRange): TableRange;
+    intersection(other: TableRange): TableRange;
+    intersectsRow(startRow: number, endRow: number): boolean;
+    intersectsCol(startCol: number, endCol: number): boolean;
+    intersects({ startRow, startColumn, endRow, endColumn }: TableRange): boolean;
+    touches(other: TableRange): boolean;
+    within(other: TableRange): boolean;
+    equals(other: TableRange): boolean;
+    difference(range: TableRange): TableRange[];
+}
+export declare function allRangesInOtherRanges(ranges: TableRange[], otherRanges: TableRange[]): boolean;
+export declare function rangesWithinOtherRanges(ranges: TableRange[], otherRanges: TableRange[]): {
+    withinRanges: {
+        range: TableRange;
+        otherRange: TableRange;
+    }[];
+    otherRanges: TableRange[];
+};
+export declare function uniqueRanges(ranges: TableRange[]): TableRange[];

package/lib/table-range.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueRanges = exports.rangesWithinOtherRanges = exports.allRangesInOtherRanges = exports.TableRange = void 0;
+class TableRange {
+    constructor(startRow, endRow, startColumn, endColumn) {
+        this.startRow = startRow;
+        this.endRow = endRow;
+        this.startColumn = startColumn;
+        this.endColumn = endColumn;
+    }
+    start() {
+        return new TableRange(this.startRow, this.startRow, this.startColumn, this.startColumn);
+    }
+    get rows() {
+        return this.endRow - this.startRow;
+    }
+    get cols() {
+        return this.endColumn - this.startColumn;
+    }
+    singular() {
+        return this.cols === 0 && this.rows === 0;
+    }
+    isStart(rowIndex, columnIndex) {
+        return this.startRow === rowIndex && this.startColumn === columnIndex;
+    }
+    eachRow(cb, max) {
+        let { endRow } = this;
+        if (max && endRow > max)
+            endRow = max;
+        for (let row = this.startRow; row <= endRow; row += 1) {
+            cb(row);
+        }
+        return this;
+    }
+    eachColumn(cb, max) {
+        let { endColumn } = this;
+        if (max && endColumn > max)
+            endColumn = max;
+        for (let col = this.startColumn; col <= endColumn; col += 1) {
+            cb(col);
+        }
+        return this;
+    }
+    each(cb) {
+        this.eachRow((row) => {
+            this.eachColumn((col) => cb(row, col));
+        });
+        return this;
+    }
+    union(other) {
+        return new TableRange(other.startRow < this.startRow ? other.startRow : this.startRow, other.endRow > this.endRow ? other.endRow : this.endRow, other.startColumn < this.startColumn ? other.startColumn : this.startColumn, other.endColumn > this.endColumn ? other.endColumn : this.endColumn);
+    }
+    intersection(other) {
+        return new TableRange(other.startRow < this.startRow ? this.startRow : other.startRow, other.endRow > this.endRow ? this.endRow : other.endRow, other.startColumn < this.startColumn ? this.startColumn : other.startColumn, other.endColumn > this.endColumn ? this.endColumn : other.endColumn);
+    }
+    intersectsRow(startRow, endRow) {
+        return this.startRow <= endRow && startRow <= this.endRow;
+    }
+    intersectsCol(startCol, endCol) {
+        return this.startColumn <= endCol && startCol <= this.endColumn;
+    }
+    intersects({ startRow, startColumn, endRow, endColumn }) {
+        return this.intersectsCol(startColumn, endColumn) && this.intersectsRow(startRow, endRow);
+    }
+    touches(other) {
+        return ((other.startRow === this.startRow &&
+            other.endRow === this.endRow &&
+            (other.endColumn + 1 === this.startColumn || this.endColumn + 1 === other.startColumn)) ||
+            (other.startColumn === this.startColumn &&
+                other.endColumn === this.endColumn &&
+                (other.endRow + 1 === this.startRow || this.endRow + 1 === other.startRow)));
+    }
+    within(other) {
+        return (this.startRow >= other.startRow &&
+            this.endRow <= other.endRow &&
+            this.startColumn >= other.startColumn &&
+            this.endColumn <= other.endColumn);
+    }
+    equals(other) {
+        return (this.startRow === other.startRow &&
+            this.endRow === other.endRow &&
+            this.startColumn === other.startColumn &&
+            this.endColumn === other.endColumn);
+    }
+    difference(range) {
+        const ret = [];
+        if (!this.intersects(range))
+            return ret;
+        const { startRow, endRow, startColumn, endColumn } = this;
+        const intersectedRange = this.intersection(range);
+        const diff = [
+            new TableRange(startRow, intersectedRange.startRow - 1, startColumn, endColumn),
+            new TableRange(intersectedRange.endRow + 1, endRow, startColumn, endColumn),
+            new TableRange(intersectedRange.startRow, intersectedRange.endRow, startColumn, intersectedRange.startColumn - 1),
+            new TableRange(intersectedRange.startRow, intersectedRange.endRow, intersectedRange.endColumn + 1, endColumn),
+        ];
+        return diff.filter((it) => it.rows >= 0 && it.cols >= 0);
+    }
+}
+exports.TableRange = TableRange;
+function allRangesInOtherRanges(ranges, otherRanges) {
+    if (ranges.length === 0)
+        return false;
+    let result = true;
+    for (const range of ranges) {
+        if (!otherRanges.find((r) => r.equals(range))) {
+            result = false;
+            break;
+        }
+    }
+    return result;
+}
+exports.allRangesInOtherRanges = allRangesInOtherRanges;
+function rangesWithinOtherRanges(ranges, otherRanges) {
+    const withinRanges = [];
+    const leftoverRanges = [];
+    ranges.forEach((range) => {
+        otherRanges.forEach((otherRange) => {
+            if (range.within(otherRange)) {
+                withinRanges.push({ range, otherRange });
+            }
+            else {
+                if (!ranges.find((r) => r.equals(otherRange)) && !leftoverRanges.find((r) => r.equals(otherRange))) {
+                    leftoverRanges.push(otherRange);
+                }
+            }
+        });
+    });
+    return { withinRanges, otherRanges: leftoverRanges };
+}
+exports.rangesWithinOtherRanges = rangesWithinOtherRanges;
+function uniqueRanges(ranges) {
+    const uniqueRanges = [];
+    ranges.forEach((range) => {
+        if (!uniqueRanges.find((r) => range.equals(r))) {
+            uniqueRanges.push(range);
+        }
+    });
+    return uniqueRanges;
+}
+exports.uniqueRanges = uniqueRanges;

package/lib/table.service.d.ts

@@ -0,0 +1,42 @@
+import { DocumentElement, PositionDefinition, SizeDefinition, StyleDefinition, DocumentElementChanges } from '@contrail/documents';
+import { TableRange } from './table-range';
+export declare enum TABLE_ERROR {
+    UNMERGE_TO_DELETE_COLUMN = "Unmerge cells to delete column",
+    UNMERGE_TO_DELETE_ROW = "Unmerge cells to delete row",
+    UMMERGE_TO_MOVE_COLUMN = "Unmerge cells to move column",
+    UMMERGE_TO_MOVE_ROW = "Unmerge cells to move row",
+    INVALID_RANGE_TO_MERGE = "Invalid range to merge",
+    INVALID_RANGE_TO_UNMERGE = "Invalid range to unmerge",
+    INVALID_TABLE = "Invalid table"
+}
+export declare function tableData(element: DocumentElement): {
+    id: string;
+    tableId: string;
+    type: string;
+};
+export declare function createCell(config: DocumentElement): DocumentElement;
+export declare class TableService {
+    constructor();
+    static DEFAULT_CELL_STYLE: StyleDefinition;
+    static createEmptyTableElement(position: PositionDefinition, rows?: number, columns?: number): Array<DocumentElement>;
+    static addColumn(tableElement: DocumentElement, childElements: DocumentElement[], index: any, optionalWidth?: number): DocumentElementChanges;
+    static getCellsAtColumn(columnId: string, tableElement: DocumentElement, childElements: DocumentElement[]): DocumentElement[];
+    static getCellsAtRow(rowId: string, tableElement: DocumentElement, childElements: DocumentElement[]): DocumentElement[];
+    static addRow(tableElement: DocumentElement, childElements: DocumentElement[], index: any, optionalHeight?: number): DocumentElementChanges;
+    static getCellsAtRanges(tableElement: DocumentElement, childElements: DocumentElement[], ranges: TableRange[]): DocumentElement[];
+    static deleteTable(tableElement: DocumentElement, childElements: DocumentElement[]): DocumentElementChanges;
+    static deleteColumns(tableElement: DocumentElement, childElements: DocumentElement[], columnIndexes: number[]): DocumentElementChanges;
+    static deleteRows(tableElement: DocumentElement, childElements: DocumentElement[], rowIndexes: number[]): DocumentElementChanges;
+    static move(key: 'columnIds' | 'rowIds', tableElement: DocumentElement, childElements: DocumentElement[], from: number, to: number): DocumentElementChanges;
+    static resizeRow(tableElement: DocumentElement, childElements: DocumentElement[], rowId: string, height: number): DocumentElementChanges;
+    static resizeColumn(tableElement: DocumentElement, childElements: DocumentElement[], columnId: string, width: number): DocumentElementChanges;
+    private static getColumns;
+    static getColumnsWidth(tableElement: DocumentElement, childElements: DocumentElement[], startIndex: number, endIndex: number): number;
+    private static getRows;
+    private static getRowsHeight;
+    private static getCellMinHeight;
+    static autoFitRows(tableElement: DocumentElement, childElements: DocumentElement[], columnId: string): DocumentElementChanges;
+    static clearCell(element: DocumentElement): void;
+    static getCellSize(element: DocumentElement, text?: string): SizeDefinition;
+    static getSize(text: string, style: string): SizeDefinition;
+}