@contrail/document-table 1.0.19-beta.0 → 1.0.20-beta.0

package/lib/table-copy.service.js

@@ -12,7 +12,7 @@ class TableCopyService {
     static copy(tableElement, childElements) {
         const copiedChildElementIds = new Map();
         const childElementsMap = new Map();
-        childElements.forEach(element => {
+        childElements.forEach((element) => {
             childElementsMap.set(element.id, element);
         });
         const rowIds = [];
@@ -56,20 +56,20 @@ class TableCopyService {
             columnIds.push(newElement.id);
             newChildElements.push(newElement);
         }
-        const cellElements = childElements.filter(e => e.type === 'cell');
+        const cellElements = childElements.filter((e) => e.type === 'cell');
         if (cellElements.length < tableElement.rowIds.length * tableElement.columnIds.length) {
             for (let i = 0; i < tableElement.rowIds.length; i++) {
                 for (let j = 0; j < tableElement.columnIds.length; j++) {
                     const rowId = tableElement.rowIds[i];
                     const columnId = tableElement.columnIds[j];
-                    const cellElement = cellElements.find(e => e.type === 'cell' && e.rowId === rowId && e.columnId === columnId);
+                    const cellElement = cellElements.find((e) => e.type === 'cell' && e.rowId === rowId && e.columnId === columnId);
                     if (!cellElement) {
-                        const row = childElements.find(e => e.id === rowId);
-                        const column = childElements.find(e => e.id === columnId);
+                        const row = childElements.find((e) => e.id === rowId);
+                        const column = childElements.find((e) => e.id === columnId);
                         cellElements.push((0, table_service_1.createCell)({
                             rowId,
                             columnId,
-                            tableId: tableElement.id,
+                            tableId: newTableElement.id,
                             size: {
                                 width: column.size.width,
                                 height: row.size.height,
@@ -112,7 +112,7 @@ class TableCopyService {
         const tableId = (0, nanoid_1.nanoid)(16);
         let width = 0, height = 0;
         let startRow, endRow, startColumn, endColumn;
-        cells.forEach(cell => {
+        cells.forEach((cell) => {
             const rowIndex = element.rowIds.indexOf(cell.rowId);
             const columnIndex = element.columnIds.indexOf(cell.columnId);
             const isNotSet = startRow == undefined;
@@ -126,8 +126,8 @@ class TableCopyService {
                 endColumn = columnIndex;
             existingCellsMap.set(`${rowIndex}_${columnIndex}`, cell);
         });
-        const skipRows = Array.from({ length: endRow - startRow + 1 }, (value, index) => startRow + index).filter(i => !Array.from(existingCellsMap.keys()).find(v => v.startsWith(`${i}_`)));
-        const skipColumns = Array.from({ length: endColumn - startColumn + 1 }, (value, index) => startColumn + index).filter(j => !Array.from(existingCellsMap.keys()).find(v => v.endsWith(`_${j}`)));
+        const skipRows = Array.from({ length: endRow - startRow + 1 }, (value, index) => startRow + index).filter((i) => !Array.from(existingCellsMap.keys()).find((v) => v.startsWith(`${i}_`)));
+        const skipColumns = Array.from({ length: endColumn - startColumn + 1 }, (value, index) => startColumn + index).filter((j) => !Array.from(existingCellsMap.keys()).find((v) => v.endsWith(`_${j}`)));
         for (let i = startRow; i <= endRow; i++) {
             if (skipRows.indexOf(i) !== -1)
                 continue;
@@ -197,7 +197,7 @@ class TableCopyService {
                 }
             }
         }
-        const { columns: existingColumns, rows: existingRows } = table_state_service_1.TableStateService.buildChildElementsState(element, new Map([...columns, ...rows].map(e => [e.id, e])), []);
+        const { columns: existingColumns, rows: existingRows } = table_state_service_1.TableStateService.buildChildElementsState(element, new Map([...columns, ...rows].map((e) => [e.id, e])), []);
         const tableElement = {
             type: 'table',
             id: tableId,
@@ -282,8 +282,7 @@ class TableCopyService {
         var _a, _b, _c, _d, _e, _f;
         const fontFamily = `${(_c = (_b = (_a = cellElement.style) === null || _a === void 0 ? void 0 : _a.font) === null || _b === void 0 ? void 0 : _b.family) !== null && _c !== void 0 ? _c : table_constants_1.DEFAULT_TEXT_FONT_FAMILY}`;
         const fontSize = `${(_f = (_e = (_d = cellElement.style) === null || _d === void 0 ? void 0 : _d.font) === null || _e === void 0 ? void 0 : _e.size) !== null && _f !== void 0 ? _f : table_constants_1.DEFAULT_TEXT_FONT_SIZE}pt`;
-        const size = table_service_1.TableService.getSize(cellElement.text, `width: ${cellElement.size.width -
-            table_constants_1.TABLE_TEXT_PADDING * 2}px; height: auto; font-family: ${fontFamily}; font-size: ${fontSize};`);
+        const size = table_service_1.TableService.getSize(cellElement.text, `width: ${cellElement.size.width - table_constants_1.TABLE_TEXT_PADDING * 2}px; height: auto; font-family: ${fontFamily}; font-size: ${fontSize};`);
         const documentElement = {
             isTextTool: true,
             text: cellElement.text,

package/lib/table-member-paste.service.js

@@ -1,100 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableMemberPasteService = void 0;
-const table_merge_service_1 = require("./table-merge.service");
 const table_state_service_1 = require("./table-state.service");
-const util_1 = require("@contrail/util");
-const nanoid_1 = require("nanoid");
+const documents_1 = require("@contrail/documents");
 class TableMemberPasteService {
     static detectMemberships(tableEl, structureEls, memberCandidates) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         const result = new Map();
         if (!tableEl || !memberCandidates.length)
             return result;
-        const childElementsMap = table_state_service_1.TableStateService.getTableElementsMap(tableEl, structureEls);
-        const nonTableEls = structureEls.filter((e) => e.type !== 'table');
-        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(tableEl, nonTableEls);
-        const { cells } = table_state_service_1.TableStateService.buildChildElementsState(tableEl, childElementsMap, mergedRanges);
-        const scale = (_b = (_a = tableEl.scale) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 1;
-        const tableX = (_d = (_c = tableEl.position) === null || _c === void 0 ? void 0 : _c.x) !== null && _d !== void 0 ? _d : 0;
-        const tableY = (_f = (_e = tableEl.position) === null || _e === void 0 ? void 0 : _e.y) !== null && _f !== void 0 ? _f : 0;
-        const rowIds = (_g = tableEl.rowIds) !== null && _g !== void 0 ? _g : [];
-        const columnIds = (_h = tableEl.columnIds) !== null && _h !== void 0 ? _h : [];
+        const tableState = table_state_service_1.TableStateService.createTableState(tableEl, structureEls, 0);
+        const rowIds = (_a = tableEl.rowIds) !== null && _a !== void 0 ? _a : [];
+        const columnIds = (_b = tableEl.columnIds) !== null && _b !== void 0 ? _b : [];
         for (const member of memberCandidates) {
-            const isLine = member.type === 'line';
-            let cx;
-            let cy;
-            let anchorX;
-            let anchorY;
-            if (isLine && member.lineDefinition) {
-                const { x1, y1, x2, y2 } = member.lineDefinition;
-                cx = (x1 + x2) / 2;
-                cy = (y1 + y2) / 2;
-                anchorX = x1;
-                anchorY = y1;
-            }
-            else if (member.position && member.size) {
-                cx = member.position.x + member.size.width / 2;
-                cy = member.position.y + member.size.height / 2;
-                anchorX = member.position.x;
-                anchorY = member.position.y;
-            }
-            else {
+            const viewBox = documents_1.DocumentElementFactory.getBoundingClientRect(member);
+            if (!viewBox)
                 continue;
+            const elementBox = table_state_service_1.TableStateService.getTableMemberCoordinateBox(viewBox);
+            const cellEl = table_state_service_1.TableStateService.getOverlappedCell(tableState, elementBox);
+            if (!cellEl)
+                continue;
+            const gridRow = rowIds.indexOf(cellEl.rowId);
+            const gridCol = columnIds.indexOf(cellEl.columnId);
+            if (gridRow === -1 || gridCol === -1)
+                continue;
+            const cellState = tableState.cells.get(cellEl.id);
+            if (!cellState)
+                continue;
+            const scale = (_d = (_c = tableEl.scale) === null || _c === void 0 ? void 0 : _c.x) !== null && _d !== void 0 ? _d : 1;
+            const tableX = (_f = (_e = tableEl.position) === null || _e === void 0 ? void 0 : _e.x) !== null && _f !== void 0 ? _f : 0;
+            const tableY = (_h = (_g = tableEl.position) === null || _g === void 0 ? void 0 : _g.y) !== null && _h !== void 0 ? _h : 0;
+            const offsetX = (elementBox.left - tableX) / scale - cellState.x;
+            const offsetY = (elementBox.top - tableY) / scale - cellState.y;
+            const entry = { gridRow, gridCol, offsetX, offsetY };
+            if (member.type === 'line' && member.lineDefinition) {
+                entry.lineDx = member.lineDefinition.x2 - member.lineDefinition.x1;
+                entry.lineDy = member.lineDefinition.y2 - member.lineDefinition.y1;
             }
-            for (const [cellId, cellState] of cells) {
-                if (cellState.isMerged)
-                    continue;
-                const cellLeft = tableX + cellState.x * scale;
-                const cellRight = cellLeft + cellState.width * scale;
-                const cellTop = tableY + cellState.y * scale;
-                const cellBottom = cellTop + cellState.height * scale;
-                const inBox = cx > cellLeft && cx < cellRight && cy > cellTop && cy < cellBottom;
-                if (!inBox)
-                    continue;
-                const cellEl = childElementsMap.get(cellId);
-                if (!cellEl)
-                    break;
-                const gridRow = rowIds.indexOf(cellEl.rowId);
-                const gridCol = columnIds.indexOf(cellEl.columnId);
-                if (gridRow === -1 || gridCol === -1)
-                    break;
-                const unscaledAnchorX = (anchorX - tableX) / scale;
-                const unscaledAnchorY = (anchorY - tableY) / scale;
-                const offsetX = unscaledAnchorX - cellState.x;
-                const offsetY = unscaledAnchorY - cellState.y;
-                const entry = { gridRow, gridCol, offsetX, offsetY };
-                if (isLine && member.lineDefinition) {
-                    entry.lineDx = member.lineDefinition.x2 - member.lineDefinition.x1;
-                    entry.lineDy = member.lineDefinition.y2 - member.lineDefinition.y1;
-                }
-                result.set(member.id, entry);
-                break;
-            }
+            result.set(member.id, entry);
         }
         return result;
     }
     static resolveMemberPositions(memberships, memberElements, targetTableEl, targetChildEls, targetRow, targetCol) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-        const newElements = [];
         if (!memberships.size)
-            return newElements;
-        const childElementsMap = table_state_service_1.TableStateService.getTableElementsMap(targetTableEl, targetChildEls);
-        const nonTableEls = targetChildEls.filter((e) => e.type !== 'table');
-        const mergedRanges = table_merge_service_1.TableMergeService.getMergedRanges(targetTableEl, nonTableEls);
-        const { cells } = table_state_service_1.TableStateService.buildChildElementsState(targetTableEl, childElementsMap, mergedRanges);
-        const scale = (_b = (_a = targetTableEl.scale) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 1;
-        const tableX = (_d = (_c = targetTableEl.position) === null || _c === void 0 ? void 0 : _c.x) !== null && _d !== void 0 ? _d : 0;
-        const tableY = (_f = (_e = targetTableEl.position) === null || _e === void 0 ? void 0 : _e.y) !== null && _f !== void 0 ? _f : 0;
-        const rowIds = (_g = targetTableEl.rowIds) !== null && _g !== void 0 ? _g : [];
-        const columnIds = (_h = targetTableEl.columnIds) !== null && _h !== void 0 ? _h : [];
-        const cellByRowCol = new Map();
-        for (const el of targetChildEls) {
-            if (el.type === 'cell' && el.rowId && el.columnId) {
-                cellByRowCol.set(`${el.rowId}-${el.columnId}`, el);
-            }
-        }
-        for (const member of memberElements) {
+            return [];
+        const tableState = table_state_service_1.TableStateService.createTableState(targetTableEl, targetChildEls, 0);
+        const rowIds = (_a = targetTableEl.rowIds) !== null && _a !== void 0 ? _a : [];
+        const columnIds = (_b = targetTableEl.columnIds) !== null && _b !== void 0 ? _b : [];
+        const scale = (_d = (_c = targetTableEl.scale) === null || _c === void 0 ? void 0 : _c.x) !== null && _d !== void 0 ? _d : 1;
+        const tableX = (_f = (_e = targetTableEl.position) === null || _e === void 0 ? void 0 : _e.x) !== null && _f !== void 0 ? _f : 0;
+        const tableY = (_h = (_g = targetTableEl.position) === null || _g === void 0 ? void 0 : _g.y) !== null && _h !== void 0 ? _h : 0;
+        const eligibleMembers = memberElements.filter((m) => memberships.has(m.id));
+        const { newElements } = documents_1.DocumentElementFactory.copyElements(eligibleMembers, targetTableEl.documentId);
+        const result = [];
+        for (let i = 0; i < eligibleMembers.length; i++) {
+            const member = eligibleMembers[i];
+            const newEl = newElements[i];
             const entry = memberships.get(member.id);
             if (!entry)
                 continue;
@@ -103,32 +65,27 @@ class TableMemberPasteService {
             const targetColId = columnIds[targetCol + gridCol];
             if (!targetRowId || !targetColId)
                 continue;
-            const targetCellEl = cellByRowCol.get(`${targetRowId}-${targetColId}`);
-            if (!targetCellEl)
+            const cellEl = tableState.childElementsMap.get(`${targetRowId}-${targetColId}`);
+            if (!cellEl)
                 continue;
-            const targetCellState = cells.get(targetCellEl.id);
-            if (!targetCellState)
+            const cellState = tableState.cells.get(cellEl.id);
+            if (!cellState)
                 continue;
-            const newEl = util_1.ObjectUtil.cloneDeep(member);
-            newEl.id = (0, nanoid_1.nanoid)(16);
-            const isLine = member.type === 'line';
-            if (isLine && member.lineDefinition) {
-                const newX1 = tableX + (targetCellState.x + offsetX) * scale;
-                const newY1 = tableY + (targetCellState.y + offsetY) * scale;
+            if (member.type === 'line' && member.lineDefinition) {
+                const newX1 = tableX + (cellState.x + offsetX) * scale;
+                const newY1 = tableY + (cellState.y + offsetY) * scale;
                 const newX2 = newX1 + ((_j = entry.lineDx) !== null && _j !== void 0 ? _j : 0);
                 const newY2 = newY1 + ((_k = entry.lineDy) !== null && _k !== void 0 ? _k : 0);
                 newEl.lineDefinition = Object.assign(Object.assign({}, newEl.lineDefinition), { x1: newX1, y1: newY1, x2: newX2, y2: newY2 });
                 if ((_l = newEl.points) === null || _l === void 0 ? void 0 : _l.length) {
-                    const oldX1 = member.lineDefinition.x1;
-                    const oldY1 = member.lineDefinition.y1;
-                    const dx = newX1 - oldX1;
-                    const dy = newY1 - oldY1;
+                    const dx = newX1 - member.lineDefinition.x1;
+                    const dy = newY1 - member.lineDefinition.y1;
                     newEl.points = newEl.points.map((p) => [p[0] + dx, p[1] + dy]);
                 }
             }
             else {
-                const newX = tableX + (targetCellState.x + offsetX) * scale;
-                const newY = tableY + (targetCellState.y + offsetY) * scale;
+                const newX = tableX + (cellState.x + offsetX) * scale;
+                const newY = tableY + (cellState.y + offsetY) * scale;
                 if (((_m = newEl.points) === null || _m === void 0 ? void 0 : _m.length) && member.position) {
                     const dx = newX - member.position.x;
                     const dy = newY - member.position.y;
@@ -136,9 +93,9 @@ class TableMemberPasteService {
                 }
                 newEl.position = { x: newX, y: newY };
             }
-            newElements.push(newEl);
+            result.push(newEl);
         }
-        return newElements;
+        return result;
     }
 }
 exports.TableMemberPasteService = TableMemberPasteService;

package/lib/table-paste.service.js

@@ -16,15 +16,15 @@ class TablePasteService {
     }
     static pasteRowsAndColumns(tableElement, childElements, elementsToPaste, targetRow, targetColumn) {
         var _a, _b, _c;
-        const tableToPaste = elementsToPaste.find(e => e.type === 'table');
-        const rowsToPaste = elementsToPaste.filter(e => e.type === 'row');
-        const columnsToPaste = elementsToPaste.filter(e => e.type === 'column');
-        const cellsToPaste = elementsToPaste.filter(e => e.type === 'cell');
+        const tableToPaste = elementsToPaste.find((e) => e.type === 'table');
+        const rowsToPaste = elementsToPaste.filter((e) => e.type === 'row');
+        const columnsToPaste = elementsToPaste.filter((e) => e.type === 'column');
+        const cellsToPaste = elementsToPaste.filter((e) => e.type === 'cell');
         const startRow = targetRow;
         const endRow = startRow + tableToPaste.rowIds.length - 1;
         const startColumn = targetColumn;
         const endColumn = startColumn + tableToPaste.columnIds.length - 1;
-        const existingCells = childElements.filter(e => e.type === 'cell');
+        const existingCells = childElements.filter((e) => e.type === 'cell');
         const elementsToCreate = [];
         const elementsToUpdate = [];
         const columnWidthsToUpdate = new Map();
@@ -33,8 +33,8 @@ class TablePasteService {
         for (let rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
             const rowToPaste = rowsToPaste[rowIndex - targetRow];
             let existingRowId = tableElement.rowIds[rowIndex];
-            let existingRow = childElements.find(e => e.type === 'row' && e.id === existingRowId) ||
-                elementsToCreate.find(e => e.type === 'row' && e.id === existingRowId);
+            let existingRow = childElements.find((e) => e.type === 'row' && e.id === existingRowId) ||
+                elementsToCreate.find((e) => e.type === 'row' && e.id === existingRowId);
             this.log('current row', rowIndex, existingRowId, existingRow);
             if (!existingRowId) {
                 const [newRow, ...newRowCells] = (_a = table_service_1.TableService.addRow(tableElement, [...existingCells, ...elementsToCreate], rowIndex, rowToPaste.size.height)) === null || _a === void 0 ? void 0 : _a.elementsToCreate;
@@ -50,8 +50,8 @@ class TablePasteService {
             for (let columnIndex = startColumn; columnIndex <= endColumn; columnIndex++) {
                 const columnToPaste = columnsToPaste[columnIndex - targetColumn];
                 let existingColumnId = tableElement.columnIds[columnIndex];
-                let existingColumn = childElements.find(e => e.type === 'column' && e.id === existingColumnId) ||
-                    elementsToCreate.find(e => e.type === 'column' && e.id === existingColumnId);
+                let existingColumn = childElements.find((e) => e.type === 'column' && e.id === existingColumnId) ||
+                    elementsToCreate.find((e) => e.type === 'column' && e.id === existingColumnId);
                 this.log('current column', columnIndex, existingColumnId, existingColumn);
                 if (!tableElement.columnIds[columnIndex]) {
                     const [newColumn, ...newColumnCells] = (_b = table_service_1.TableService.addColumn(tableElement, [...existingCells, ...elementsToCreate], columnIndex, columnToPaste.size.width)) === null || _b === void 0 ? void 0 : _b.elementsToCreate;
@@ -65,14 +65,14 @@ class TablePasteService {
                         columnWidthsToUpdate.get(existingColumnId) < columnToPaste.size.width)) {
                     columnWidthsToUpdate.set(existingColumnId, columnToPaste.size.width);
                 }
-                const cellToPaste = cellsToPaste.find(e => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
+                const cellToPaste = cellsToPaste.find((e) => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
                 if (!cellToPaste)
                     continue;
                 const cellRange = new table_range_1.TableRange(rowIndex, rowIndex, columnIndex, columnIndex);
-                const mergedRange = existingMergedRanges.find(range => range.intersects(cellRange));
+                const mergedRange = existingMergedRanges.find((range) => range.intersects(cellRange));
                 const mergedRangeOther = mergedRange && !cellRange.equals(mergedRange.start());
                 if (mergedRange) {
-                    existingMergedRanges = existingMergedRanges.filter(r => !r.equals(mergedRange));
+                    existingMergedRanges = existingMergedRanges.filter((r) => !r.equals(mergedRange));
                 }
                 if (mergedRangeOther) {
                     const [updatedTable, ...unmergedCellAndRow] = (_c = table_merge_service_1.TableMergeService.unmerge(tableElement, childElements, mergedRange)) === null || _c === void 0 ? void 0 : _c.elementsToUpdate;
@@ -100,34 +100,34 @@ class TablePasteService {
         return { elementsToCreate, elementsToUpdate };
     }
     static pasteTableCells(tableElement, childElements, elementsToPaste, targetRow, targetColumn) {
-        const memberCandidates = elementsToPaste.filter(e => table_state_service_1.TableStateService.isValidTableMember(e));
-        const structureElements = elementsToPaste.filter(e => !table_state_service_1.TableStateService.isValidTableMember(e));
-        const tableToPaste = structureElements.find(e => e.type === 'table');
-        const rowsToPaste = structureElements.filter(e => e.type === 'row');
-        const columnsToPaste = structureElements.filter(e => e.type === 'column');
-        const cellsToPaste = structureElements.filter(e => e.type === 'cell');
+        const memberCandidates = elementsToPaste.filter((e) => table_state_service_1.TableStateService.isValidTableMember(e));
+        const structureElements = elementsToPaste.filter((e) => !table_state_service_1.TableStateService.isValidTableMember(e));
+        const tableToPaste = structureElements.find((e) => e.type === 'table');
+        const rowsToPaste = structureElements.filter((e) => e.type === 'row');
+        const columnsToPaste = structureElements.filter((e) => e.type === 'column');
+        const cellsToPaste = structureElements.filter((e) => e.type === 'cell');
         const startRow = targetRow;
         const endRow = startRow + tableToPaste.rowIds.length - 1;
         const startColumn = targetColumn;
         const endColumn = startColumn + tableToPaste.columnIds.length - 1;
-        const existingCells = childElements.filter(e => e.type === 'cell');
+        const existingCells = childElements.filter((e) => e.type === 'cell');
         const tableUndo = util_1.ObjectUtil.cloneDeep(tableElement);
         const { elementsToUpdate, elementsToCreate } = TablePasteService.pasteRowsAndColumns(tableElement, childElements, structureElements, targetRow, targetColumn);
         for (let rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
             const rowToPaste = rowsToPaste[rowIndex - targetRow];
             const existingRowId = tableElement.rowIds[rowIndex];
-            const existingRow = childElements.find(e => e.type === 'row' && e.id === existingRowId) ||
-                elementsToCreate.find(e => e.type === 'row' && e.id === existingRowId);
+            const existingRow = childElements.find((e) => e.type === 'row' && e.id === existingRowId) ||
+                elementsToCreate.find((e) => e.type === 'row' && e.id === existingRowId);
             for (let columnIndex = startColumn; columnIndex <= endColumn; columnIndex++) {
                 const columnToPaste = columnsToPaste[columnIndex - targetColumn];
                 const existingColumnId = tableElement.columnIds[columnIndex];
-                const existingColumn = childElements.find(e => e.type === 'column' && e.id === existingColumnId) ||
-                    elementsToCreate.find(e => e.type === 'column' && e.id === existingColumnId);
-                const cellToPaste = cellsToPaste.find(e => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
+                const existingColumn = childElements.find((e) => e.type === 'column' && e.id === existingColumnId) ||
+                    elementsToCreate.find((e) => e.type === 'column' && e.id === existingColumnId);
+                const cellToPaste = cellsToPaste.find((e) => e.rowId === rowToPaste.id && e.columnId === columnToPaste.id);
                 if (!cellToPaste)
                     continue;
-                const createdCell = elementsToCreate.find(e => e.type === 'cell' && e.rowId === existingRowId && e.columnId === existingColumnId);
-                const existingCell = existingCells.find(e => e.rowId === existingRowId && e.columnId === existingColumnId);
+                const createdCell = elementsToCreate.find((e) => e.type === 'cell' && e.rowId === existingRowId && e.columnId === existingColumnId);
+                const existingCell = existingCells.find((e) => e.rowId === existingRowId && e.columnId === existingColumnId);
                 const cell = createdCell !== null && createdCell !== void 0 ? createdCell : existingCell;
                 const cellUndo = util_1.ObjectUtil.cloneDeep(cell);
                 this.log('cell to paste', cellToPaste);
@@ -172,7 +172,7 @@ class TablePasteService {
             if (memberships.size > 0) {
                 const allTargetChildren = [
                     ...childElements,
-                    ...elementsToCreate.filter(e => table_constants_1.TABLE_STRUCTURE_TYPES.includes(e.type)),
+                    ...elementsToCreate.filter((e) => table_constants_1.TABLE_STRUCTURE_TYPES.includes(e.type)),
                 ];
                 const newMembers = table_member_paste_service_1.TableMemberPasteService.resolveMemberPositions(memberships, memberCandidates, tableElement, allTargetChildren, targetRow, targetColumn);
                 elementsToCreate.push(...newMembers);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/document-table",
-  "version": "1.0.19-beta.0",
+  "version": "1.0.20-beta.0",
   "description": "Library for document tables",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",