@worktile/theia 16.3.2 → 16.3.3

package/fesm2022/worktile-theia.mjs

@@ -2132,7 +2132,10 @@ function copyNode(editor, element, thyNotifyService, codeMirrorEditor) {
     if (IS_SAFARI) {
         copyNodeForSafari(editor, element);
     }
-    document.execCommand('copy') ? thyNotifyService.success('复制成功') : thyNotifyService.error('复制失败');
+    const isSuccess = document.execCommand('copy');
+    if (thyNotifyService) {
+        isSuccess ? thyNotifyService.success('复制成功') : thyNotifyService.error('复制失败');
+    }
     if (IS_SAFARI) {
         window.getSelection().removeAllRanges();
     }
@@ -6447,6 +6450,151 @@ function setCellIndent(editor, indentType, child, at) {
     }
 }
 
+function splitCell(editor) {
+    const tablePosition = createTablePosition(editor);
+    const { cell, table, cellEntry } = tablePosition;
+    if ((!cell.rowspan && !cell.colspan) || (cell.rowspan === 1 && cell.colspan === 1))
+        return editor;
+    const cellRow = tablePosition.getRowIndex();
+    const cellCol = tablePosition.getColumnIndex();
+    resetTableCell(editor, table, cell, cellRow, cellCol);
+    Transforms.select(editor, cellEntry[1]);
+    Transforms.collapse(editor, { edge: 'end' });
+}
+function resetTableCell(editor, table, cell, cellRow, cellCol) {
+    const rowSpanIndex = cellRow + (cell.rowspan || 1) - 1;
+    const colSpanIndex = cellCol + (cell.colspan || 1) - 1;
+    Editor.withoutNormalizing(editor, () => {
+        table.children.map((row, rowIndex) => {
+            row.children.map((col, colIndex) => {
+                if (rowIndex >= cellRow && rowIndex <= rowSpanIndex && colIndex >= cellCol && colIndex <= colSpanIndex) {
+                    const path = findPath(editor, col);
+                    Transforms.setNodes(editor, { colspan: null, rowspan: null, hidden: null }, { at: path });
+                }
+            });
+        });
+    });
+}
+
+const getTableEntry = (editor) => {
+    const { tableEntry } = createTablePosition(editor);
+    return tableEntry;
+};
+const getTablePath = (editor) => {
+    const tableEntry = getTableEntry(editor);
+    return tableEntry[1];
+};
+const getTable = (editor) => {
+    const { tableEntry } = createTablePosition(editor);
+    return tableEntry[0];
+};
+const getSelectedCell = (editor) => {
+    if (editor && editor.selection) {
+        const { cell } = createTablePosition(editor);
+        return cell;
+    }
+    return null;
+};
+
+function isSelectedCellMerged(editor) {
+    if (editor && editor.selection) {
+        const opts = new TableOptions();
+        const { anchor } = editor.selection;
+        const { cell } = TablePosition.create(opts, editor, anchor.path);
+        if (cell) {
+            return (cell.colspan && cell.colspan !== 1) || (cell.rowspan && cell.rowspan !== 1);
+        }
+    }
+    return false;
+}
+function getLeftCellDict(selectCellNodes) {
+    return selectCellNodes.reduce((dict, cell) => {
+        if (!dict[cell.row]) {
+            dict[cell.row] = cell;
+        }
+        return dict;
+    }, {});
+}
+function calculateCellSpan(selectCellNodes, leftCellDict) {
+    let rowspan = 0, colspan = 0, crossCount = -1;
+    selectCellNodes
+        .filter(item => !item.node.hidden)
+        .forEach(item => {
+        const { row } = item;
+        if (item.row === selectCellNodes[0].row) {
+            colspan += item.node.colspan || 1;
+        }
+        const maxRowSpan = leftCellDict[row].maxRowSpan || 1;
+        leftCellDict[row].maxRowSpan = (item.node.rowspan || 1) > maxRowSpan ? item.node.rowspan : maxRowSpan;
+    });
+    Object.values(leftCellDict).forEach((item) => {
+        const { row, maxRowSpan } = item;
+        if (crossCount < row) {
+            rowspan += maxRowSpan;
+            crossCount = row + maxRowSpan - 1;
+        }
+    });
+    return { rowspan, colspan };
+}
+function mergeCell(editor, selectedCells) {
+    sortCell(selectedCells);
+    const selectCellNodes = getSelectCellNode(editor, selectedCells);
+    Editor.withoutNormalizing(editor, () => {
+        let leftTopCellPath;
+        const leftCellDict = getLeftCellDict(selectCellNodes);
+        selectCellNodes.forEach((cell, index) => {
+            const { row, node } = cell;
+            if (node) {
+                const cellPath = findPath(editor, node);
+                if (index === 0) {
+                    leftTopCellPath = cellPath;
+                }
+                else {
+                    mergeCellContent(editor, leftTopCellPath, cellPath);
+                    Transforms.setNodes(editor, { colspan: null, rowspan: null, hidden: true }, { at: cellPath });
+                }
+            }
+        });
+        let { rowspan, colspan } = calculateCellSpan(selectCellNodes, leftCellDict);
+        Transforms.setNodes(editor, { rowspan, colspan }, { at: leftTopCellPath });
+        Transforms.select(editor, leftTopCellPath);
+        Transforms.collapse(editor, { edge: 'end' });
+    });
+}
+function mergeCellContent(editor, leftTopCellPath, cellPath) {
+    Editor.withoutNormalizing(editor, () => {
+        const { path } = Editor.end(editor, leftTopCellPath);
+        const endRange = Editor.range(editor, Editor.start(editor, cellPath), Editor.end(editor, cellPath));
+        let tableCell;
+        path.pop();
+        const nextPath = Path.next(path);
+        Transforms.moveNodes(editor, {
+            at: endRange,
+            to: nextPath,
+            match: node => {
+                if (Element$1.isElement(node) && node.type === ElementKinds.tableCell) {
+                    tableCell = node;
+                }
+                if (Element$1.isElement(node) && node.type && tableCell && tableCell.children.includes(node)) {
+                    const isSingleEmptyParagraph = tableCell.children.length === 1 && Editor.isEmpty(editor, node) && node.type === ElementKinds.default;
+                    return !isSingleEmptyParagraph && true;
+                }
+            }
+        });
+    });
+}
+// 计算合并前的单元格
+function getCellPositionsBeforeMerge(editor, { row, col }) {
+    const pos = createTablePosition(editor);
+    const { rowspan, colspan } = pos.findCellByPath({ row, col });
+    if (rowspan || colspan) {
+        const colSpan = colspan ?? 1;
+        const rowSpan = rowspan ?? 1;
+        return getCellPositionsFromRange(row, col, row + rowSpan, col + colSpan);
+    }
+    return [{ row, col }];
+}
+
 const TableEditor = {
     insertTable(editor, optionsParam) {
         const opts = new TableOptions(optionsParam);
@@ -6476,11 +6624,84 @@ const TableEditor = {
         const opts = new TableOptions(optionsParam);
         clearCell(opts, editor, nodeEntry);
     },
+    setCellsBackgroundColor(editor, color, selectCells) {
+        let cells = selectCells;
+        if (!cells) {
+            cells = TableEditor.getSelectedCells(editor) || [];
+        }
+        if (cells.length) {
+            // 点击自定义颜色面板输入框设置颜色值时，会丢失焦点和选区（目前无法做到焦点同时存在于编辑器和输入框）
+            let location;
+            if (!editor.selection) {
+                const { rangeRef } = THE_EDITOR_PREVIOUS_SELECTION.get(editor);
+                location = rangeRef.current.anchor;
+            }
+            const isHeader = TableEditor.isActiveHeader(editor, location);
+            if (color === 'transparent' ||
+                (color === TableHeaderBackgroundColor && isHeader) ||
+                (color === SpecialBackgroundColor && !isHeader)) {
+                color = null;
+            }
+            Editor.withoutNormalizing(editor, () => {
+                cells.map(cell => {
+                    const cellPath = AngularEditor.findPath(editor, cell);
+                    Transforms.setNodes(editor, { backgroundColor: color }, { at: cellPath });
+                });
+            });
+        }
+    },
+    mergeCell(editor) {
+        const selectedCellsPosition = TableEditor.getSelectedCellPositions(editor);
+        selectedCellsPosition.length && mergeCell(editor, selectedCellsPosition);
+    },
+    splitCell(editor) {
+        splitCell(editor);
+    },
+    setTableOptions(editor, newOptions) {
+        const tablePosition = createTablePosition(editor);
+        const tablePath = getTablePath(editor);
+        const table = tablePosition.table;
+        const options = { ...table.options, ...newOptions };
+        Transforms.setNodes(editor, { options }, { at: tablePath });
+    },
+    setEquallyColumn(editor) {
+        const [tableEntry] = Editor.nodes(editor, { at: editor.selection, match: (n) => n.type === ElementKinds.table });
+        const tableElement = (tableEntry && tableEntry[0]);
+        if (tableElement) {
+            const columns = tableElement.columns;
+            const sumWidth = columns.reduce((previousValue, currentValue) => {
+                return previousValue + currentValue.width;
+            }, 0);
+            const equalColumns = columns.map(() => {
+                return { width: sumWidth / columns.length };
+            });
+            setNode(editor, { columns: equalColumns }, tableElement);
+        }
+    },
+    clearCellsContent(editor, selectCells) {
+        let cells = selectCells;
+        if (!cells) {
+            cells = TableEditor.getSelectedCellPositions(editor) || [];
+        }
+        if (cells.length > 0) {
+            const tablePosition = createTablePosition(editor);
+            if (tablePosition.isInTable()) {
+                Editor.withoutNormalizing(editor, () => {
+                    for (const { row, col } of cells) {
+                        const cellPath = [...tablePosition.tableEntry[1], row, col];
+                        const node = Node.get(editor, cellPath);
+                        TableEditor.clearCell(editor, [node, cellPath]);
+                    }
+                });
+                Transforms.select(editor, Editor.start(editor, tablePosition.cellEntry[1]));
+            }
+        }
+    },
     isActive(editor) {
         const [table] = Editor.nodes(editor, { match: n => Element$1.isElement(n) && n.type === ElementKinds.table });
         return !!table;
     },
-    getSelectedCells(editor) {
+    getSelectedCellPositions(editor) {
         const tableNode = getAboveByType(editor, ElementKinds.table);
         if (tableNode) {
             const tableComponent = ELEMENT_TO_COMPONENT.get(tableNode[0]);
@@ -6491,6 +6712,14 @@ const TableEditor = {
         }
         return null;
     },
+    getSelectedCells(editor) {
+        const tableNode = getAboveByType(editor, ElementKinds.table);
+        if (tableNode) {
+            const tableComponent = ELEMENT_TO_COMPONENT.get(tableNode[0]);
+            return tableComponent?.tableStore?.selectedCells || null;
+        }
+        return null;
+    },
     setAlign(editor, alignment) {
         return TableEditor.handleSelectedCells(editor, (_, cellRange) => {
             Transforms.setNodes(editor, { align: alignment }, {
@@ -6518,7 +6747,7 @@ const TableEditor = {
         return true;
     },
     isVerticalAlignActive(editor, alignment) {
-        const cells = TableEditor.getSelectedCells(editor);
+        const cells = TableEditor.getSelectedCellPositions(editor);
         if (cells) {
             const lastCell = cells[cells.length - 1];
             const tableNode = getAboveByType(editor, ElementKinds.table);
@@ -6575,7 +6804,7 @@ const TableEditor = {
         });
     },
     handleSelectedCells(editor, handle) {
-        const cells = TableEditor.getSelectedCells(editor);
+        const cells = TableEditor.getSelectedCellPositions(editor);
         if (cells) {
             const tableNode = getAboveByType(editor, ElementKinds.table);
             Editor.withoutNormalizing(editor, () => {
@@ -6618,14 +6847,14 @@ const TableEditor = {
             match: n => Element$1.isElement(n) &&
                 ((n.type === ElementKinds.tableRow && n.header) || (n.type === ElementKinds.table && n.options?.headerRow))
         });
-        const selectedCells = TableEditor.getSelectedCells(editor) ?? [];
+        const selectedCells = TableEditor.getSelectedCellPositions(editor) ?? [];
         sortCell(selectedCells);
         const isContainHeaderRow = !!selectedCells && selectedCells[0].row === 0;
         return isHeaderRow && isContainHeaderRow;
     },
     hasHeaderColumnCell(editor) {
         const table = getAboveByType(editor, ElementKinds.table);
-        const selectedCells = TableEditor.getSelectedCells(editor) ?? [];
+        const selectedCells = TableEditor.getSelectedCellPositions(editor) ?? [];
         sortCell(selectedCells);
         const isContainHeaderColumn = !!selectedCells && selectedCells[0].col === 0;
         const isHeaderColumn = table && table[0] && table[0]?.options?.headerColumn;
@@ -11534,133 +11763,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.4", ngImpor
                 args: ['mousedown', ['$event']]
             }] } });
 
-function isSelectedCellMerged(editor) {
-    if (editor && editor.selection) {
-        const opts = new TableOptions();
-        const { anchor } = editor.selection;
-        const { cell } = TablePosition.create(opts, editor, anchor.path);
-        if (cell) {
-            return (cell.colspan && cell.colspan !== 1) || (cell.rowspan && cell.rowspan !== 1);
-        }
-    }
-    return false;
-}
-function getLeftCellDict(selectCellNodes) {
-    return selectCellNodes.reduce((dict, cell) => {
-        if (!dict[cell.row]) {
-            dict[cell.row] = cell;
-        }
-        return dict;
-    }, {});
-}
-function calculateCellSpan(selectCellNodes, leftCellDict) {
-    let rowspan = 0, colspan = 0, crossCount = -1;
-    selectCellNodes
-        .filter(item => !item.node.hidden)
-        .forEach(item => {
-        const { row } = item;
-        if (item.row === selectCellNodes[0].row) {
-            colspan += item.node.colspan || 1;
-        }
-        const maxRowSpan = leftCellDict[row].maxRowSpan || 1;
-        leftCellDict[row].maxRowSpan = (item.node.rowspan || 1) > maxRowSpan ? item.node.rowspan : maxRowSpan;
-    });
-    Object.values(leftCellDict).forEach((item) => {
-        const { row, maxRowSpan } = item;
-        if (crossCount < row) {
-            rowspan += maxRowSpan;
-            crossCount = row + maxRowSpan - 1;
-        }
-    });
-    return { rowspan, colspan };
-}
-function mergeCell(editor, selectedCells) {
-    sortCell(selectedCells);
-    const selectCellNodes = getSelectCellNode(editor, selectedCells);
-    Editor.withoutNormalizing(editor, () => {
-        let leftTopCellPath;
-        const leftCellDict = getLeftCellDict(selectCellNodes);
-        selectCellNodes.forEach((cell, index) => {
-            const { row, node } = cell;
-            if (node) {
-                const cellPath = findPath(editor, node);
-                if (index === 0) {
-                    leftTopCellPath = cellPath;
-                }
-                else {
-                    mergeCellContent(editor, leftTopCellPath, cellPath);
-                    Transforms.setNodes(editor, { colspan: null, rowspan: null, hidden: true }, { at: cellPath });
-                }
-            }
-        });
-        let { rowspan, colspan } = calculateCellSpan(selectCellNodes, leftCellDict);
-        Transforms.setNodes(editor, { rowspan, colspan }, { at: leftTopCellPath });
-        Transforms.select(editor, leftTopCellPath);
-        Transforms.collapse(editor, { edge: 'end' });
-    });
-}
-function mergeCellContent(editor, leftTopCellPath, cellPath) {
-    Editor.withoutNormalizing(editor, () => {
-        const { path } = Editor.end(editor, leftTopCellPath);
-        const endRange = Editor.range(editor, Editor.start(editor, cellPath), Editor.end(editor, cellPath));
-        let tableCell;
-        path.pop();
-        const nextPath = Path.next(path);
-        Transforms.moveNodes(editor, {
-            at: endRange,
-            to: nextPath,
-            match: node => {
-                if (Element$1.isElement(node) && node.type === ElementKinds.tableCell) {
-                    tableCell = node;
-                }
-                if (Element$1.isElement(node) && node.type && tableCell && tableCell.children.includes(node)) {
-                    const isSingleEmptyParagraph = tableCell.children.length === 1 && Editor.isEmpty(editor, node) && node.type === ElementKinds.default;
-                    return !isSingleEmptyParagraph && true;
-                }
-            }
-        });
-    });
-}
-// 计算合并前的单元格
-function getCellPositionsBeforeMerge(editor, { row, col }) {
-    const pos = createTablePosition(editor);
-    const { rowspan, colspan } = pos.findCellByPath({ row, col });
-    if (rowspan || colspan) {
-        const colSpan = colspan ?? 1;
-        const rowSpan = rowspan ?? 1;
-        return getCellPositionsFromRange(row, col, row + rowSpan, col + colSpan);
-    }
-    return [{ row, col }];
-}
-
-const getTableEntry = (editor) => {
-    const { tableEntry } = createTablePosition(editor);
-    return tableEntry;
-};
-const getTablePath = (editor) => {
-    const tableEntry = getTableEntry(editor);
-    return tableEntry[1];
-};
-const getTable = (editor) => {
-    const { tableEntry } = createTablePosition(editor);
-    return tableEntry[0];
-};
-const getSelectedCell = (editor) => {
-    if (editor && editor.selection) {
-        const { cell } = createTablePosition(editor);
-        return cell;
-    }
-    return null;
-};
-
-function setTableOptions(editor, newOptions) {
-    const tablePosition = createTablePosition(editor);
-    const tablePath = getTablePath(editor);
-    const table = tablePosition.table;
-    const options = { ...table.options, ...newOptions };
-    Transforms.setNodes(editor, { options }, { at: tablePath });
-}
-
 function removeColumnOrRows(editor, tableStore, options) {
     const { isSelectedTable } = tableStore;
     const selectedRowsIndex = options?.selectedRowsIndex || tableStore.selectedRowsIndex;
@@ -11674,7 +11776,7 @@ function removeColumnOrRows(editor, tableStore, options) {
     if (selectedRowsIndex.length > 0 && selectedColumnsIndex.length === 0) {
         // 删除行时取消标题行
         if (tablePosition.table && tableComponent.headerRow && selectedRowsIndex.includes(0)) {
-            setTableOptions(editor, { headerRow: false });
+            TableEditor.setTableOptions(editor, { headerRow: false });
             // headerRow 兼容代码, 取消标题行的时候同时设置 row 中的 header 属性
             if (tablePosition.table.children[0].header) {
                 const rowPath = TheEditor.findPath(editor, tablePosition.table.children[0]);
@@ -11691,7 +11793,7 @@ function removeColumnOrRows(editor, tableStore, options) {
     if (selectedColumnsIndex.length > 0 && selectedRowsIndex.length === 0) {
         // 删除列时取消标题列
         if (tablePosition.table && tablePosition.table.options?.headerColumn && selectedColumnsIndex.includes(0)) {
-            setTableOptions(editor, { headerColumn: false });
+            TableEditor.setTableOptions(editor, { headerColumn: false });
         }
         selectedColumnsIndex
             .sort((a, b) => b - a)
@@ -11702,25 +11804,6 @@ function removeColumnOrRows(editor, tableStore, options) {
     }
 }
 
-const setSelectedCellsBackgroundColor = (editor, color, tableStore) => {
-    // 点击自定义颜色面板输入框设置颜色值时，会丢失焦点和选区（目前无法做到焦点同时存在于编辑器和输入框）
-    let location;
-    if (!editor.selection) {
-        const { rangeRef } = THE_EDITOR_PREVIOUS_SELECTION.get(editor);
-        location = rangeRef.current.anchor;
-    }
-    const isHeader = TableEditor.isActiveHeader(editor, location);
-    if (color === 'transparent') {
-        color = null;
-    }
-    if ((color === TableHeaderBackgroundColor && isHeader) || (color === SpecialBackgroundColor && !isHeader)) {
-        tableStore.setSelectedCellsBackgroundColor(null);
-    }
-    else {
-        tableStore.setSelectedCellsBackgroundColor(color);
-    }
-};
-
 function setCellMenuVisibility(editor, menuList, tableInfo) {
     const { selectedCellPositions, isFullscreen, isSelectedTable, selectedRowsIndex, selectedColumnsIndex } = tableInfo;
     const isCellMerged = isSelectedCellMerged(editor);
@@ -11761,32 +11844,6 @@ function setCellMenuVisibility(editor, menuList, tableInfo) {
     });
 }
 
-function splitCell(editor) {
-    const tablePosition = createTablePosition(editor);
-    const { cell, table, cellEntry } = tablePosition;
-    if ((!cell.rowspan && !cell.colspan) || (cell.rowspan === 1 && cell.colspan === 1))
-        return editor;
-    const cellRow = tablePosition.getRowIndex();
-    const cellCol = tablePosition.getColumnIndex();
-    resetTableCell(editor, table, cell, cellRow, cellCol);
-    Transforms.select(editor, cellEntry[1]);
-    Transforms.collapse(editor, { edge: 'end' });
-}
-function resetTableCell(editor, table, cell, cellRow, cellCol) {
-    const rowSpanIndex = cellRow + (cell.rowspan || 1) - 1;
-    const colSpanIndex = cellCol + (cell.colspan || 1) - 1;
-    Editor.withoutNormalizing(editor, () => {
-        table.children.map((row, rowIndex) => {
-            row.children.map((col, colIndex) => {
-                if (rowIndex >= cellRow && rowIndex <= rowSpanIndex && colIndex >= cellCol && colIndex <= colSpanIndex) {
-                    const path = findPath(editor, col);
-                    Transforms.setNodes(editor, { colspan: null, rowspan: null, hidden: null }, { at: path });
-                }
-            });
-        });
-    });
-}
-
 const getMinAndMaxCellIndex = (editor, selectedCellPositions, maxRow, maxCol, minRow, minCol, table) => {
     const beforeCols = [];
     const beforeRows = [];
@@ -12166,29 +12223,6 @@ class TableStore {
         this.dangerousColumnsIndex = [...Array(pos.getWidth())].map((_, i) => i);
         this.dangerousCells$.next(cells);
     }
-    setSelectedCellsBackgroundColor(backgroundColor) {
-        const cells = this.selectedCells$.getValue();
-        Editor.withoutNormalizing(this.editor, () => {
-            cells.map(cell => {
-                const cellPath = AngularEditor.findPath(this.editor, cell);
-                Transforms.setNodes(this.editor, { backgroundColor }, { at: cellPath });
-            });
-        });
-    }
-    clearSelectedCellsContent() {
-        const cells = this.getSelectedCellPositions();
-        const tablePosition = createTablePosition(this.editor);
-        if (tablePosition.isInTable()) {
-            Editor.withoutNormalizing(this.editor, () => {
-                for (const { row, col } of cells) {
-                    const cellPath = [...tablePosition.tableEntry[1], row, col];
-                    const node = Node.get(this.editor, cellPath);
-                    TableEditor.clearCell(this.editor, [node, cellPath]);
-                }
-            });
-            Transforms.select(this.editor, Editor.start(this.editor, tablePosition.cellEntry[1]));
-        }
-    }
     /**
      * 聚焦单元格并设置聚焦相关路径及元素
      */
@@ -12308,7 +12342,7 @@ class TheTableContextMenuService {
                 visibility: true,
                 actionHandle: () => { },
                 activeHandle: (event, item) => {
-                    setSelectedCellsBackgroundColor(this.editor, item.backgroundColor, this.tableStore);
+                    TableEditor.setCellsBackgroundColor(this.editor, item.backgroundColor);
                 },
                 deactivateHandle: (event) => {
                     if (event.relatedTarget instanceof HTMLElement) {
@@ -12378,7 +12412,7 @@ class TheTableContextMenuService {
                 name: '清空选中区域',
                 visibility: true,
                 actionHandle: () => {
-                    this.tableStore.clearSelectedCellsContent();
+                    TableEditor.clearCellsContent(this.editor);
                     this.tableStore.selectFirstCell();
                 }
             },
@@ -12388,7 +12422,7 @@ class TheTableContextMenuService {
                 name: '合并单元格',
                 visibility: true,
                 actionHandle: () => {
-                    mergeCell(this.editor, this.tableStore.getSelectedCellPositions());
+                    TableEditor.mergeCell(this.editor);
                 }
             },
             {
@@ -12398,7 +12432,7 @@ class TheTableContextMenuService {
                 divider: true,
                 visibility: true,
                 actionHandle: () => {
-                    splitCell(this.editor);
+                    TableEditor.splitCell(this.editor);
                 }
             },
             {
@@ -12630,7 +12664,7 @@ class TheTableOptionsComponent {
         currentOption.isActive = !option.isActive;
         const tableOption = {};
         tableOption[option.key] = currentOption.isActive || false;
-        setTableOptions(this.editor, { ...tableOption });
+        TableEditor.setTableOptions(this.editor, { ...tableOption });
         // headerRow 兼容代码, 取消标题行的时候同时设置 row 中的 header 属性
         if (option.key === TableOperations.headerRow && !tableOption[option.key] && this.table.children[0].header) {
             const rowPath = TheEditor.findPath(this.editor, this.table.children[0]);
@@ -12697,7 +12731,7 @@ class TheTableToolbarComponent {
                 visibility: false,
                 icon: 'table-merge-cells',
                 actionHandle: () => {
-                    mergeCell(this.editor, this.tableStore.getSelectedCellPositions());
+                    TableEditor.mergeCell(this.editor);
                     this.popoverRef.close();
                     this.tableStore.clearSelectedCells();
                 }
@@ -12708,7 +12742,7 @@ class TheTableToolbarComponent {
                 visibility: false,
                 icon: 'table-unmerge-cells',
                 actionHandle: () => {
-                    splitCell(this.editor);
+                    TableEditor.splitCell(this.editor);
                     this.popoverRef.close();
                     this.tableStore.clearSelectedCells();
                 }
@@ -12775,7 +12809,7 @@ class TheTableToolbarComponent {
         e.stopPropagation();
     }
     changeColor(newColor) {
-        setSelectedCellsBackgroundColor(this.editor, newColor, this.tableStore);
+        TableEditor.setCellsBackgroundColor(this.editor, newColor);
         this.selectedColor = newColor;
     }
     setFullscreen(event) {
@@ -12792,14 +12826,7 @@ class TheTableToolbarComponent {
     }
     setEquallyColumnHandle(event) {
         this.preventDefault(event);
-        const columns = this.tableElement.columns;
-        const sumWidth = columns.reduce((previousValue, currentValue) => {
-            return previousValue + currentValue.width;
-        }, 0);
-        const equalColumns = columns.map(() => {
-            return { width: sumWidth / columns.length };
-        });
-        setNode(this.editor, { columns: equalColumns }, this.tableElement);
+        TableEditor.setEquallyColumn(this.editor);
     }
     openTableOptionMenu(event) {
         this.preventDefault(event);
@@ -13901,7 +13928,7 @@ class TheTableComponent extends TheBaseElementComponent {
         }), takeUntil(this.destroy$))
             .subscribe((e) => {
             if (e.type === 'keydown') {
-                this.tableStore.clearSelectedCellsContent();
+                TableEditor.clearCellsContent(this.editor);
             }
             const isCurrentTableElement = this.nativeElement.contains(e.target);
             if (!isCurrentTableElement || (!this.tableStore.pointerSelection && !this.tableStore.areaSelection)) {
@@ -15681,7 +15708,7 @@ const withTable = (editor) => {
                     TableEditor.removeTable(editor);
                 }
                 else {
-                    tableComponent.tableStore.clearSelectedCellsContent();
+                    TableEditor.clearCellsContent(editor, selectedCellPositions);
                 }
                 tableComponent.tableService.closeToolbar();
             });