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

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 export * from './table-border-ranges';
 export * from './table-constants';
 export * from './table-copy.service';
+export * from './table-member-paste.service';
 export * from './table-merge.service';
 export * from './table-paste.service';
 export * from './table-rotate.service';

package/lib/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./table-border-ranges"), exports);
 __exportStar(require("./table-constants"), exports);
 __exportStar(require("./table-copy.service"), exports);
+__exportStar(require("./table-member-paste.service"), exports);
 __exportStar(require("./table-merge.service"), exports);
 __exportStar(require("./table-paste.service"), exports);
 __exportStar(require("./table-rotate.service"), exports);

package/lib/table-constants.d.ts

@@ -8,3 +8,4 @@ export declare const DEFAULT_TEXT_FONT_FAMILY = "Roboto";
 export declare const DEFAULT_TEXT_FONT_SIZE = 11;
 export declare const TEXT_VALIGN = "top";
 export declare const TEXT_ALIGN = "left";
+export declare const TABLE_STRUCTURE_TYPES: string[];

package/lib/table-constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TEXT_ALIGN = exports.TEXT_VALIGN = exports.DEFAULT_TEXT_FONT_SIZE = exports.DEFAULT_TEXT_FONT_FAMILY = exports.TRANSPARENT_COLOR = exports.TABLE_TEXT_PADDING = exports.TABLE_CELL_HEIGHT = exports.TABLE_CELL_WIDTH = exports.TABLE_COLUMN_MIN_WIDTH = exports.TABLE_ROW_MIN_HEIGHT = void 0;
+exports.TABLE_STRUCTURE_TYPES = exports.TEXT_ALIGN = exports.TEXT_VALIGN = exports.DEFAULT_TEXT_FONT_SIZE = exports.DEFAULT_TEXT_FONT_FAMILY = exports.TRANSPARENT_COLOR = exports.TABLE_TEXT_PADDING = exports.TABLE_CELL_HEIGHT = exports.TABLE_CELL_WIDTH = exports.TABLE_COLUMN_MIN_WIDTH = exports.TABLE_ROW_MIN_HEIGHT = void 0;
 exports.TABLE_ROW_MIN_HEIGHT = 28;
 exports.TABLE_COLUMN_MIN_WIDTH = 28;
 exports.TABLE_CELL_WIDTH = 200;
@@ -11,3 +11,4 @@ exports.DEFAULT_TEXT_FONT_FAMILY = 'Roboto';
 exports.DEFAULT_TEXT_FONT_SIZE = 11;
 exports.TEXT_VALIGN = 'top';
 exports.TEXT_ALIGN = 'left';
+exports.TABLE_STRUCTURE_TYPES = ['table', 'column', 'row', 'cell'];

package/lib/table-copy.service.js

@@ -6,12 +6,13 @@ const util_1 = require("@contrail/util");
 const nanoid_1 = require("nanoid");
 const table_constants_1 = require("./table-constants");
 const table_service_1 = require("./table.service");
+const table_state_service_1 = require("./table-state.service");
 class TableCopyService {
     constructor() { }
     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 = [];
@@ -55,16 +56,16 @@ 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,
@@ -101,6 +102,7 @@ class TableCopyService {
         return [newTableElement, ...newChildElements];
     }
     static createTableFromCells(element, rows, columns, cells) {
+        var _a, _b, _c, _d;
         const rowElements = [];
         const rowIds = new Map();
         const columnElements = [];
@@ -110,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;
@@ -124,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;
@@ -195,10 +197,14 @@ class TableCopyService {
                 }
             }
         }
+        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,
-            position: Object.assign({}, element.position),
+            position: {
+                x: element.position.x + existingColumns.get(columns[startColumn].id).x * ((_b = (_a = element === null || element === void 0 ? void 0 : element.scale) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 1),
+                y: element.position.y + existingRows.get(rows[startRow].id).y * ((_d = (_c = element === null || element === void 0 ? void 0 : element.scale) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : 1),
+            },
             scale: Object.assign({}, element.scale),
             size: {
                 width,
@@ -276,7 +282,8 @@ 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.d.ts

@@ -0,0 +1,14 @@
+import { DocumentElement } from '@contrail/documents';
+interface MembershipEntry {
+    gridRow: number;
+    gridCol: number;
+    offsetX: number;
+    offsetY: number;
+    lineDx?: number;
+    lineDy?: number;
+}
+export declare class TableMemberPasteService {
+    static detectMemberships(tableEl: DocumentElement, structureEls: DocumentElement[], memberCandidates: DocumentElement[]): Map<string, MembershipEntry>;
+    static resolveMemberPositions(memberships: Map<string, MembershipEntry>, memberElements: DocumentElement[], targetTableEl: DocumentElement, targetChildEls: DocumentElement[], targetRow: number, targetCol: number): DocumentElement[];
+}
+export {};

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

@@ -0,0 +1,144 @@
+"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");
+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 : [];
+        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 {
+                continue;
+            }
+            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;
+            }
+        }
+        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) {
+            const entry = memberships.get(member.id);
+            if (!entry)
+                continue;
+            const { gridRow, gridCol, offsetX, offsetY } = entry;
+            const targetRowId = rowIds[targetRow + gridRow];
+            const targetColId = columnIds[targetCol + gridCol];
+            if (!targetRowId || !targetColId)
+                continue;
+            const targetCellEl = cellByRowCol.get(`${targetRowId}-${targetColId}`);
+            if (!targetCellEl)
+                continue;
+            const targetCellState = cells.get(targetCellEl.id);
+            if (!targetCellState)
+                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;
+                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;
+                    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;
+                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;
+                    newEl.points = newEl.points.map((p) => [p[0] + dx, p[1] + dy]);
+                }
+                newEl.position = { x: newX, y: newY };
+            }
+            newElements.push(newEl);
+        }
+        return newElements;
+    }
+}
+exports.TableMemberPasteService = TableMemberPasteService;

package/lib/table-paste.service.js

@@ -3,9 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TablePasteService = void 0;
 const documents_1 = require("@contrail/documents");
 const util_1 = require("@contrail/util");
+const table_member_paste_service_1 = require("./table-member-paste.service");
 const table_merge_service_1 = require("./table-merge.service");
 const table_service_1 = require("./table.service");
 const table_range_1 = require("./table-range");
+const table_state_service_1 = require("./table-state.service");
+const table_constants_1 = require("./table-constants");
 class TablePasteService {
     constructor() { }
     static log(...message) {
@@ -13,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();
@@ -30,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;
@@ -47,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;
@@ -62,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;
@@ -97,33 +100,34 @@ class TablePasteService {
         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');
-        this.log(elementsToPaste);
+        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, elementsToPaste, targetRow, targetColumn);
+        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);
@@ -163,6 +167,17 @@ class TablePasteService {
             change: tableElement,
             undo: tableUndo,
         });
+        if (memberCandidates.length > 0) {
+            const memberships = table_member_paste_service_1.TableMemberPasteService.detectMemberships(tableToPaste, structureElements, memberCandidates);
+            if (memberships.size > 0) {
+                const allTargetChildren = [
+                    ...childElements,
+                    ...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);
+            }
+        }
         return {
             elementsToUpdate,
             elementsToCreate,

package/lib/table-state.service.d.ts

@@ -74,7 +74,7 @@ export declare class TableStateService {
     }): Map<string, TableMemberState>;
     static getTableMembersToDelete(tableElement: DocumentElement, childElements: DocumentElement[], tableMembersToUpdate: Map<string, TableMemberToUpdate>): Map<string, TableMemberToUpdate>;
     static adjustTableMemberPositions(tableElement: DocumentElement, childElements: DocumentElement[], tableMembersToUpdate: Map<string, TableMemberToUpdate>): Map<string, TableMemberToUpdate>;
-    static updatePositionWithDelta(element: DocumentElement, position: PositionDefinition, deltaX: number, deltaY: number): void;
+    static updatePositionWithDelta(startingElement: DocumentElement, startingPosition: PositionDefinition, deltaX: number, deltaY: number): void;
     static getElementPositionChange(element: DocumentElement, startingElement: DocumentElement): {
         change: DocumentElement;
         undo: DocumentElement;

package/lib/table-state.service.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableStateService = void 0;
-const documents_1 = require("@contrail/documents");
 const document_table_1 = require("@contrail/document-table");
 const util_1 = require("@contrail/util");
 class TableStateService {
@@ -48,7 +47,7 @@ class TableStateService {
                 }
                 if (cell && column && row) {
                     const cellRange = new document_table_1.TableRange(rowIndex, rowIndex, columnIndex, columnIndex);
-                    const mergedRange = mergedRanges.find(range => cellRange.within(range));
+                    const mergedRange = mergedRanges.find((range) => cellRange.within(range));
                     const mergedRangeStart = mergedRange && cellRange.equals(mergedRange.start());
                     const mergedRangeOther = mergedRange && !cellRange.equals(mergedRange.start());
                     const width = mergedRangeStart
@@ -93,9 +92,9 @@ class TableStateService {
     }
     static getMemberIdsForCellIds(table, cellIds) {
         const memberIds = new Set();
-        cellIds.forEach(cellId => {
+        cellIds.forEach((cellId) => {
             var _a, _b;
-            (_b = (_a = table.cellToMembers) === null || _a === void 0 ? void 0 : _a.get(cellId)) === null || _b === void 0 ? void 0 : _b.forEach(elementId => {
+            (_b = (_a = table.cellToMembers) === null || _a === void 0 ? void 0 : _a.get(cellId)) === null || _b === void 0 ? void 0 : _b.forEach((elementId) => {
                 memberIds.add(elementId);
             });
         });
@@ -118,7 +117,7 @@ class TableStateService {
                     const cellMembers = (_e = table.cellToMembers) === null || _e === void 0 ? void 0 : _e.get(cell.id);
                     if ((cellMembers === null || cellMembers === void 0 ? void 0 : cellMembers.size) > 0 &&
                         (includeAll || (rowIndexes === null || rowIndexes === void 0 ? void 0 : rowIndexes.includes(rowIndex)) || (columnIndexes === null || columnIndexes === void 0 ? void 0 : columnIndexes.includes(columnIndex)))) {
-                        cellMembers.forEach(memberId => {
+                        cellMembers.forEach((memberId) => {
                             tableMembers.set(memberId, {
                                 memberId,
                                 rowId,
@@ -168,26 +167,19 @@ class TableStateService {
         }
         return affectedTableMembers;
     }
-    static updatePositionWithDelta(element, position, deltaX, deltaY) {
-        var _a, _b, _c;
-        if (element.type === 'line') {
-            if (element.lineDefinition) {
-                element.lineDefinition = Object.assign(Object.assign({}, util_1.ObjectUtil.cloneDeep(element.lineDefinition)), { x1: element.lineDefinition.x1 + deltaX, y1: element.lineDefinition.y1 + deltaY, x2: element.lineDefinition.x2 + deltaX, y2: element.lineDefinition.y2 + deltaY });
+    static updatePositionWithDelta(startingElement, startingPosition, deltaX, deltaY) {
+        var _a;
+        if (startingElement.type === 'line') {
+            if (startingElement.lineDefinition) {
+                startingElement.lineDefinition = Object.assign(Object.assign({}, util_1.ObjectUtil.cloneDeep(startingElement.lineDefinition)), { x1: startingElement.lineDefinition.x1 + deltaX, y1: startingElement.lineDefinition.y1 + deltaY, x2: startingElement.lineDefinition.x2 + deltaX, y2: startingElement.lineDefinition.y2 + deltaY });
             }
         }
         else {
-            const isThumbnailOnlyComponent = documents_1.ItemComponentService.isThumbnailOnlyComponent(element);
-            let pr = 0;
-            let pt = 0;
-            if (documents_1.ItemComponentService.isItemComponent(element) && !isThumbnailOnlyComponent) {
-                pr = 8;
-                pt = 18;
-            }
-            element.position = Object.assign(Object.assign({}, element.position), { x: ((isThumbnailOnlyComponent ? (_a = element.position) === null || _a === void 0 ? void 0 : _a.x : position === null || position === void 0 ? void 0 : position.x) || 0) + deltaX + pr, y: ((isThumbnailOnlyComponent ? (_b = element.position) === null || _b === void 0 ? void 0 : _b.y : position === null || position === void 0 ? void 0 : position.y) || 0) + deltaY + pt });
+            startingElement.position = Object.assign(Object.assign({}, startingElement.position), { x: ((startingPosition === null || startingPosition === void 0 ? void 0 : startingPosition.x) || 0) + deltaX, y: ((startingPosition === null || startingPosition === void 0 ? void 0 : startingPosition.y) || 0) + deltaY });
         }
-        if (['callout', 'line'].indexOf(element.type) !== -1 && ((_c = element.points) === null || _c === void 0 ? void 0 : _c.length) > 0) {
-            const points = element.points.map(([x, y]) => [x + deltaX, y + deltaY]);
-            element.points = points;
+        if (['callout', 'line'].indexOf(startingElement.type) !== -1 && ((_a = startingElement.points) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            const points = startingElement.points.map(([x, y]) => [x + deltaX, y + deltaY]);
+            startingElement.points = points;
         }
     }
     static getElementPositionChange(element, startingElement) {
@@ -215,20 +207,20 @@ class TableStateService {
     }
     static getTableElementsMap(tableElement, tableChildElements) {
         var _a;
-        const childElementsMap = new Map(tableChildElements.map(el => [el.id, el]));
+        const childElementsMap = new Map(tableChildElements.map((el) => [el.id, el]));
         const tableState = new Map();
-        (_a = tableElement.rowIds) === null || _a === void 0 ? void 0 : _a.forEach(rowId => {
+        (_a = tableElement.rowIds) === null || _a === void 0 ? void 0 : _a.forEach((rowId) => {
             var _a;
             const row = childElementsMap.get(rowId);
             if (row) {
                 tableState.set(rowId, row);
             }
-            (_a = tableElement.columnIds) === null || _a === void 0 ? void 0 : _a.forEach(columnId => {
+            (_a = tableElement.columnIds) === null || _a === void 0 ? void 0 : _a.forEach((columnId) => {
                 const column = childElementsMap.get(columnId);
                 if (column) {
                     tableState.set(columnId, column);
                 }
-                const cell = tableChildElements.find(el => el.rowId === rowId && el.columnId === columnId);
+                const cell = tableChildElements.find((el) => el.rowId === rowId && el.columnId === columnId);
                 if (cell) {
                     const compositeId = `${rowId}-${columnId}`;
                     tableState.set(cell.id, cell);

package/package.json

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