@ckeditor/ckeditor5-table 40.0.0 → 40.2.0

package/src/commands/mergecellcommand.js

@@ -1,198 +1,198 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-import { Command } from 'ckeditor5/src/core';
-import TableWalker from '../tablewalker';
-import { isHeadingColumnCell } from '../utils/common';
-import { removeEmptyRowsColumns } from '../utils/structure';
-/**
- * The merge cell command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'mergeTableCellRight'`, `'mergeTableCellLeft'`,
- * `'mergeTableCellUp'` and `'mergeTableCellDown'` editor commands.
- *
- * To merge a table cell at the current selection with another cell, execute the command corresponding with the preferred direction.
- *
- * For example, to merge with a cell to the right:
- *
- * ```ts
- * editor.execute( 'mergeTableCellRight' );
- * ```
- *
- * **Note**: If a table cell has a different [`rowspan`](https://www.w3.org/TR/html50/tabular-data.html#attr-tdth-rowspan)
- * (for `'mergeTableCellRight'` and `'mergeTableCellLeft'`) or [`colspan`](https://www.w3.org/TR/html50/tabular-data.html#attr-tdth-colspan)
- * (for `'mergeTableCellUp'` and `'mergeTableCellDown'`), the command will be disabled.
- */
-export default class MergeCellCommand extends Command {
-    /**
-     * Creates a new `MergeCellCommand` instance.
-     *
-     * @param editor The editor on which this command will be used.
-     * @param options.direction Indicates which cell to merge with the currently selected one.
-     * Possible values are: `'left'`, `'right'`, `'up'` and `'down'`.
-     */
-    constructor(editor, options) {
-        super(editor);
-        this.direction = options.direction;
-        this.isHorizontal = this.direction == 'right' || this.direction == 'left';
-    }
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const cellToMerge = this._getMergeableCell();
-        this.value = cellToMerge;
-        this.isEnabled = !!cellToMerge;
-    }
-    /**
-     * Executes the command.
-     *
-     * Depending on the command's {@link #direction} value, it will merge the cell that is to the `'left'`, `'right'`, `'up'` or `'down'`.
-     *
-     * @fires execute
-     */
-    execute() {
-        const model = this.editor.model;
-        const doc = model.document;
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const tableCell = tableUtils.getTableCellsContainingSelection(doc.selection)[0];
-        const cellToMerge = this.value;
-        const direction = this.direction;
-        model.change(writer => {
-            const isMergeNext = direction == 'right' || direction == 'down';
-            // The merge mechanism is always the same so sort cells to be merged.
-            const cellToExpand = (isMergeNext ? tableCell : cellToMerge);
-            const cellToRemove = (isMergeNext ? cellToMerge : tableCell);
-            // Cache the parent of cell to remove for later check.
-            const removedTableCellRow = cellToRemove.parent;
-            mergeTableCells(cellToRemove, cellToExpand, writer);
-            const spanAttribute = this.isHorizontal ? 'colspan' : 'rowspan';
-            const cellSpan = parseInt(tableCell.getAttribute(spanAttribute) || '1');
-            const cellToMergeSpan = parseInt(cellToMerge.getAttribute(spanAttribute) || '1');
-            // Update table cell span attribute and merge set selection on merged contents.
-            writer.setAttribute(spanAttribute, cellSpan + cellToMergeSpan, cellToExpand);
-            writer.setSelection(writer.createRangeIn(cellToExpand));
-            const tableUtils = this.editor.plugins.get('TableUtils');
-            const table = removedTableCellRow.findAncestor('table');
-            // Remove empty rows and columns after merging.
-            removeEmptyRowsColumns(table, tableUtils);
-        });
-    }
-    /**
-     * Returns a cell that can be merged with the current cell depending on the command's direction.
-     */
-    _getMergeableCell() {
-        const model = this.editor.model;
-        const doc = model.document;
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const tableCell = tableUtils.getTableCellsContainingSelection(doc.selection)[0];
-        if (!tableCell) {
-            return;
-        }
-        // First get the cell on proper direction.
-        const cellToMerge = this.isHorizontal ?
-            getHorizontalCell(tableCell, this.direction, tableUtils) :
-            getVerticalCell(tableCell, this.direction, tableUtils);
-        if (!cellToMerge) {
-            return;
-        }
-        // If found check if the span perpendicular to merge direction is equal on both cells.
-        const spanAttribute = this.isHorizontal ? 'rowspan' : 'colspan';
-        const span = parseInt(tableCell.getAttribute(spanAttribute) || '1');
-        const cellToMergeSpan = parseInt(cellToMerge.getAttribute(spanAttribute) || '1');
-        if (cellToMergeSpan === span) {
-            return cellToMerge;
-        }
-    }
-}
-/**
- * Returns the cell that can be merged horizontally.
- */
-function getHorizontalCell(tableCell, direction, tableUtils) {
-    const tableRow = tableCell.parent;
-    const table = tableRow.parent;
-    const horizontalCell = direction == 'right' ? tableCell.nextSibling : tableCell.previousSibling;
-    const hasHeadingColumns = (table.getAttribute('headingColumns') || 0) > 0;
-    if (!horizontalCell) {
-        return;
-    }
-    // Sort cells:
-    const cellOnLeft = (direction == 'right' ? tableCell : horizontalCell);
-    const cellOnRight = (direction == 'right' ? horizontalCell : tableCell);
-    // Get their column indexes:
-    const { column: leftCellColumn } = tableUtils.getCellLocation(cellOnLeft);
-    const { column: rightCellColumn } = tableUtils.getCellLocation(cellOnRight);
-    const leftCellSpan = parseInt(cellOnLeft.getAttribute('colspan') || '1');
-    const isCellOnLeftInHeadingColumn = isHeadingColumnCell(tableUtils, cellOnLeft);
-    const isCellOnRightInHeadingColumn = isHeadingColumnCell(tableUtils, cellOnRight);
-    // We cannot merge heading columns cells with regular cells.
-    if (hasHeadingColumns && isCellOnLeftInHeadingColumn != isCellOnRightInHeadingColumn) {
-        return;
-    }
-    // The cell on the right must have index that is distant to the cell on the left by the left cell's width (colspan).
-    const cellsAreTouching = leftCellColumn + leftCellSpan === rightCellColumn;
-    // If the right cell's column index is different it means that there are rowspanned cells between them.
-    return cellsAreTouching ? horizontalCell : undefined;
-}
-/**
- * Returns the cell that can be merged vertically.
- */
-function getVerticalCell(tableCell, direction, tableUtils) {
-    const tableRow = tableCell.parent;
-    const table = tableRow.parent;
-    const rowIndex = table.getChildIndex(tableRow);
-    // Don't search for mergeable cell if direction points out of the table.
-    if ((direction == 'down' && rowIndex === tableUtils.getRows(table) - 1) || (direction == 'up' && rowIndex === 0)) {
-        return null;
-    }
-    const rowspan = parseInt(tableCell.getAttribute('rowspan') || '1');
-    const headingRows = table.getAttribute('headingRows') || 0;
-    const isMergeWithBodyCell = direction == 'down' && (rowIndex + rowspan) === headingRows;
-    const isMergeWithHeadCell = direction == 'up' && rowIndex === headingRows;
-    // Don't search for mergeable cell if direction points out of the current table section.
-    if (headingRows && (isMergeWithBodyCell || isMergeWithHeadCell)) {
-        return null;
-    }
-    const currentCellRowSpan = parseInt(tableCell.getAttribute('rowspan') || '1');
-    const rowOfCellToMerge = direction == 'down' ? rowIndex + currentCellRowSpan : rowIndex;
-    const tableMap = [...new TableWalker(table, { endRow: rowOfCellToMerge })];
-    const currentCellData = tableMap.find(value => value.cell === tableCell);
-    const mergeColumn = currentCellData.column;
-    const cellToMergeData = tableMap.find(({ row, cellHeight, column }) => {
-        if (column !== mergeColumn) {
-            return false;
-        }
-        if (direction == 'down') {
-            // If merging a cell below the mergeRow is already calculated.
-            return row === rowOfCellToMerge;
-        }
-        else {
-            // If merging a cell above calculate if it spans to mergeRow.
-            return rowOfCellToMerge === row + cellHeight;
-        }
-    });
-    return cellToMergeData && cellToMergeData.cell ? cellToMergeData.cell : null;
-}
-/**
- * Merges two table cells. It will ensure that after merging cells with an empty paragraph, the resulting table cell will only have one
- * paragraph. If one of the merged table cells is empty, the merged table cell will have the contents of the non-empty table cell.
- * If both are empty, the merged table cell will have only one empty paragraph.
- */
-function mergeTableCells(cellToRemove, cellToExpand, writer) {
-    if (!isEmpty(cellToRemove)) {
-        if (isEmpty(cellToExpand)) {
-            writer.remove(writer.createRangeIn(cellToExpand));
-        }
-        writer.move(writer.createRangeIn(cellToRemove), writer.createPositionAt(cellToExpand, 'end'));
-    }
-    // Remove merged table cell.
-    writer.remove(cellToRemove);
-}
-/**
- * Checks if the passed table cell contains an empty paragraph.
- */
-function isEmpty(tableCell) {
-    const firstTableChild = tableCell.getChild(0);
-    return tableCell.childCount == 1 && firstTableChild.is('element', 'paragraph') && firstTableChild.isEmpty;
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import { Command } from 'ckeditor5/src/core';
+import TableWalker from '../tablewalker';
+import { isHeadingColumnCell } from '../utils/common';
+import { removeEmptyRowsColumns } from '../utils/structure';
+/**
+ * The merge cell command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'mergeTableCellRight'`, `'mergeTableCellLeft'`,
+ * `'mergeTableCellUp'` and `'mergeTableCellDown'` editor commands.
+ *
+ * To merge a table cell at the current selection with another cell, execute the command corresponding with the preferred direction.
+ *
+ * For example, to merge with a cell to the right:
+ *
+ * ```ts
+ * editor.execute( 'mergeTableCellRight' );
+ * ```
+ *
+ * **Note**: If a table cell has a different [`rowspan`](https://www.w3.org/TR/html50/tabular-data.html#attr-tdth-rowspan)
+ * (for `'mergeTableCellRight'` and `'mergeTableCellLeft'`) or [`colspan`](https://www.w3.org/TR/html50/tabular-data.html#attr-tdth-colspan)
+ * (for `'mergeTableCellUp'` and `'mergeTableCellDown'`), the command will be disabled.
+ */
+export default class MergeCellCommand extends Command {
+    /**
+     * Creates a new `MergeCellCommand` instance.
+     *
+     * @param editor The editor on which this command will be used.
+     * @param options.direction Indicates which cell to merge with the currently selected one.
+     * Possible values are: `'left'`, `'right'`, `'up'` and `'down'`.
+     */
+    constructor(editor, options) {
+        super(editor);
+        this.direction = options.direction;
+        this.isHorizontal = this.direction == 'right' || this.direction == 'left';
+    }
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const cellToMerge = this._getMergeableCell();
+        this.value = cellToMerge;
+        this.isEnabled = !!cellToMerge;
+    }
+    /**
+     * Executes the command.
+     *
+     * Depending on the command's {@link #direction} value, it will merge the cell that is to the `'left'`, `'right'`, `'up'` or `'down'`.
+     *
+     * @fires execute
+     */
+    execute() {
+        const model = this.editor.model;
+        const doc = model.document;
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const tableCell = tableUtils.getTableCellsContainingSelection(doc.selection)[0];
+        const cellToMerge = this.value;
+        const direction = this.direction;
+        model.change(writer => {
+            const isMergeNext = direction == 'right' || direction == 'down';
+            // The merge mechanism is always the same so sort cells to be merged.
+            const cellToExpand = (isMergeNext ? tableCell : cellToMerge);
+            const cellToRemove = (isMergeNext ? cellToMerge : tableCell);
+            // Cache the parent of cell to remove for later check.
+            const removedTableCellRow = cellToRemove.parent;
+            mergeTableCells(cellToRemove, cellToExpand, writer);
+            const spanAttribute = this.isHorizontal ? 'colspan' : 'rowspan';
+            const cellSpan = parseInt(tableCell.getAttribute(spanAttribute) || '1');
+            const cellToMergeSpan = parseInt(cellToMerge.getAttribute(spanAttribute) || '1');
+            // Update table cell span attribute and merge set selection on merged contents.
+            writer.setAttribute(spanAttribute, cellSpan + cellToMergeSpan, cellToExpand);
+            writer.setSelection(writer.createRangeIn(cellToExpand));
+            const tableUtils = this.editor.plugins.get('TableUtils');
+            const table = removedTableCellRow.findAncestor('table');
+            // Remove empty rows and columns after merging.
+            removeEmptyRowsColumns(table, tableUtils);
+        });
+    }
+    /**
+     * Returns a cell that can be merged with the current cell depending on the command's direction.
+     */
+    _getMergeableCell() {
+        const model = this.editor.model;
+        const doc = model.document;
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const tableCell = tableUtils.getTableCellsContainingSelection(doc.selection)[0];
+        if (!tableCell) {
+            return;
+        }
+        // First get the cell on proper direction.
+        const cellToMerge = this.isHorizontal ?
+            getHorizontalCell(tableCell, this.direction, tableUtils) :
+            getVerticalCell(tableCell, this.direction, tableUtils);
+        if (!cellToMerge) {
+            return;
+        }
+        // If found check if the span perpendicular to merge direction is equal on both cells.
+        const spanAttribute = this.isHorizontal ? 'rowspan' : 'colspan';
+        const span = parseInt(tableCell.getAttribute(spanAttribute) || '1');
+        const cellToMergeSpan = parseInt(cellToMerge.getAttribute(spanAttribute) || '1');
+        if (cellToMergeSpan === span) {
+            return cellToMerge;
+        }
+    }
+}
+/**
+ * Returns the cell that can be merged horizontally.
+ */
+function getHorizontalCell(tableCell, direction, tableUtils) {
+    const tableRow = tableCell.parent;
+    const table = tableRow.parent;
+    const horizontalCell = direction == 'right' ? tableCell.nextSibling : tableCell.previousSibling;
+    const hasHeadingColumns = (table.getAttribute('headingColumns') || 0) > 0;
+    if (!horizontalCell) {
+        return;
+    }
+    // Sort cells:
+    const cellOnLeft = (direction == 'right' ? tableCell : horizontalCell);
+    const cellOnRight = (direction == 'right' ? horizontalCell : tableCell);
+    // Get their column indexes:
+    const { column: leftCellColumn } = tableUtils.getCellLocation(cellOnLeft);
+    const { column: rightCellColumn } = tableUtils.getCellLocation(cellOnRight);
+    const leftCellSpan = parseInt(cellOnLeft.getAttribute('colspan') || '1');
+    const isCellOnLeftInHeadingColumn = isHeadingColumnCell(tableUtils, cellOnLeft);
+    const isCellOnRightInHeadingColumn = isHeadingColumnCell(tableUtils, cellOnRight);
+    // We cannot merge heading columns cells with regular cells.
+    if (hasHeadingColumns && isCellOnLeftInHeadingColumn != isCellOnRightInHeadingColumn) {
+        return;
+    }
+    // The cell on the right must have index that is distant to the cell on the left by the left cell's width (colspan).
+    const cellsAreTouching = leftCellColumn + leftCellSpan === rightCellColumn;
+    // If the right cell's column index is different it means that there are rowspanned cells between them.
+    return cellsAreTouching ? horizontalCell : undefined;
+}
+/**
+ * Returns the cell that can be merged vertically.
+ */
+function getVerticalCell(tableCell, direction, tableUtils) {
+    const tableRow = tableCell.parent;
+    const table = tableRow.parent;
+    const rowIndex = table.getChildIndex(tableRow);
+    // Don't search for mergeable cell if direction points out of the table.
+    if ((direction == 'down' && rowIndex === tableUtils.getRows(table) - 1) || (direction == 'up' && rowIndex === 0)) {
+        return null;
+    }
+    const rowspan = parseInt(tableCell.getAttribute('rowspan') || '1');
+    const headingRows = table.getAttribute('headingRows') || 0;
+    const isMergeWithBodyCell = direction == 'down' && (rowIndex + rowspan) === headingRows;
+    const isMergeWithHeadCell = direction == 'up' && rowIndex === headingRows;
+    // Don't search for mergeable cell if direction points out of the current table section.
+    if (headingRows && (isMergeWithBodyCell || isMergeWithHeadCell)) {
+        return null;
+    }
+    const currentCellRowSpan = parseInt(tableCell.getAttribute('rowspan') || '1');
+    const rowOfCellToMerge = direction == 'down' ? rowIndex + currentCellRowSpan : rowIndex;
+    const tableMap = [...new TableWalker(table, { endRow: rowOfCellToMerge })];
+    const currentCellData = tableMap.find(value => value.cell === tableCell);
+    const mergeColumn = currentCellData.column;
+    const cellToMergeData = tableMap.find(({ row, cellHeight, column }) => {
+        if (column !== mergeColumn) {
+            return false;
+        }
+        if (direction == 'down') {
+            // If merging a cell below the mergeRow is already calculated.
+            return row === rowOfCellToMerge;
+        }
+        else {
+            // If merging a cell above calculate if it spans to mergeRow.
+            return rowOfCellToMerge === row + cellHeight;
+        }
+    });
+    return cellToMergeData && cellToMergeData.cell ? cellToMergeData.cell : null;
+}
+/**
+ * Merges two table cells. It will ensure that after merging cells with an empty paragraph, the resulting table cell will only have one
+ * paragraph. If one of the merged table cells is empty, the merged table cell will have the contents of the non-empty table cell.
+ * If both are empty, the merged table cell will have only one empty paragraph.
+ */
+function mergeTableCells(cellToRemove, cellToExpand, writer) {
+    if (!isEmpty(cellToRemove)) {
+        if (isEmpty(cellToExpand)) {
+            writer.remove(writer.createRangeIn(cellToExpand));
+        }
+        writer.move(writer.createRangeIn(cellToRemove), writer.createPositionAt(cellToExpand, 'end'));
+    }
+    // Remove merged table cell.
+    writer.remove(cellToRemove);
+}
+/**
+ * Checks if the passed table cell contains an empty paragraph.
+ */
+function isEmpty(tableCell) {
+    const firstTableChild = tableCell.getChild(0);
+    return tableCell.childCount == 1 && firstTableChild.is('element', 'paragraph') && firstTableChild.isEmpty;
+}

package/src/commands/mergecellscommand.d.ts

@@ -1,28 +1,28 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-import { Command } from 'ckeditor5/src/core';
-/**
- * The merge cells command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'mergeTableCells'` editor command.
- *
- * For example, to merge selected table cells:
- *
- * ```ts
- * editor.execute( 'mergeTableCells' );
- * ```
- */
-export default class MergeCellsCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    refresh(): void;
-    /**
-     * Executes the command.
-     *
-     * @fires execute
-     */
-    execute(): void;
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import { Command } from 'ckeditor5/src/core';
+/**
+ * The merge cells command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'mergeTableCells'` editor command.
+ *
+ * For example, to merge selected table cells:
+ *
+ * ```ts
+ * editor.execute( 'mergeTableCells' );
+ * ```
+ */
+export default class MergeCellsCommand extends Command {
+    /**
+     * @inheritDoc
+     */
+    refresh(): void;
+    /**
+     * Executes the command.
+     *
+     * @fires execute
+     */
+    execute(): void;
+}

package/src/commands/mergecellscommand.js

@@ -1,94 +1,94 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-import { Command } from 'ckeditor5/src/core';
-import TableUtils from '../tableutils';
-import { updateNumericAttribute } from '../utils/common';
-import { removeEmptyRowsColumns } from '../utils/structure';
-/**
- * The merge cells command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'mergeTableCells'` editor command.
- *
- * For example, to merge selected table cells:
- *
- * ```ts
- * editor.execute( 'mergeTableCells' );
- * ```
- */
-export default class MergeCellsCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const tableUtils = this.editor.plugins.get(TableUtils);
-        const selectedTableCells = tableUtils.getSelectedTableCells(this.editor.model.document.selection);
-        this.isEnabled = tableUtils.isSelectionRectangular(selectedTableCells);
-    }
-    /**
-     * Executes the command.
-     *
-     * @fires execute
-     */
-    execute() {
-        const model = this.editor.model;
-        const tableUtils = this.editor.plugins.get(TableUtils);
-        model.change(writer => {
-            const selectedTableCells = tableUtils.getSelectedTableCells(model.document.selection);
-            // All cells will be merged into the first one.
-            const firstTableCell = selectedTableCells.shift();
-            // Update target cell dimensions.
-            const { mergeWidth, mergeHeight } = getMergeDimensions(firstTableCell, selectedTableCells, tableUtils);
-            updateNumericAttribute('colspan', mergeWidth, firstTableCell, writer);
-            updateNumericAttribute('rowspan', mergeHeight, firstTableCell, writer);
-            for (const tableCell of selectedTableCells) {
-                mergeTableCells(tableCell, firstTableCell, writer);
-            }
-            const table = firstTableCell.findAncestor('table');
-            // Remove rows and columns that become empty (have no anchored cells).
-            removeEmptyRowsColumns(table, tableUtils);
-            writer.setSelection(firstTableCell, 'in');
-        });
-    }
-}
-/**
- *  Merges two table cells. It will ensure that after merging cells with empty paragraphs the resulting table cell will only have one
- * paragraph. If one of the merged table cells is empty, the merged table cell will have contents of the non-empty table cell.
- * If both are empty, the merged table cell will have only one empty paragraph.
- */
-function mergeTableCells(cellBeingMerged, targetCell, writer) {
-    if (!isEmpty(cellBeingMerged)) {
-        if (isEmpty(targetCell)) {
-            writer.remove(writer.createRangeIn(targetCell));
-        }
-        writer.move(writer.createRangeIn(cellBeingMerged), writer.createPositionAt(targetCell, 'end'));
-    }
-    // Remove merged table cell.
-    writer.remove(cellBeingMerged);
-}
-/**
- * Checks if the passed table cell contains an empty paragraph.
- */
-function isEmpty(tableCell) {
-    const firstTableChild = tableCell.getChild(0);
-    return tableCell.childCount == 1 && firstTableChild.is('element', 'paragraph') && firstTableChild.isEmpty;
-}
-function getMergeDimensions(firstTableCell, selectedTableCells, tableUtils) {
-    let maxWidthOffset = 0;
-    let maxHeightOffset = 0;
-    for (const tableCell of selectedTableCells) {
-        const { row, column } = tableUtils.getCellLocation(tableCell);
-        maxWidthOffset = getMaxOffset(tableCell, column, maxWidthOffset, 'colspan');
-        maxHeightOffset = getMaxOffset(tableCell, row, maxHeightOffset, 'rowspan');
-    }
-    // Update table cell span attribute and merge set selection on a merged contents.
-    const { row: firstCellRow, column: firstCellColumn } = tableUtils.getCellLocation(firstTableCell);
-    const mergeWidth = maxWidthOffset - firstCellColumn;
-    const mergeHeight = maxHeightOffset - firstCellRow;
-    return { mergeWidth, mergeHeight };
-}
-function getMaxOffset(tableCell, start, currentMaxOffset, which) {
-    const dimensionValue = parseInt(tableCell.getAttribute(which) || '1');
-    return Math.max(currentMaxOffset, start + dimensionValue);
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import { Command } from 'ckeditor5/src/core';
+import TableUtils from '../tableutils';
+import { updateNumericAttribute } from '../utils/common';
+import { removeEmptyRowsColumns } from '../utils/structure';
+/**
+ * The merge cells command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'mergeTableCells'` editor command.
+ *
+ * For example, to merge selected table cells:
+ *
+ * ```ts
+ * editor.execute( 'mergeTableCells' );
+ * ```
+ */
+export default class MergeCellsCommand extends Command {
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const tableUtils = this.editor.plugins.get(TableUtils);
+        const selectedTableCells = tableUtils.getSelectedTableCells(this.editor.model.document.selection);
+        this.isEnabled = tableUtils.isSelectionRectangular(selectedTableCells);
+    }
+    /**
+     * Executes the command.
+     *
+     * @fires execute
+     */
+    execute() {
+        const model = this.editor.model;
+        const tableUtils = this.editor.plugins.get(TableUtils);
+        model.change(writer => {
+            const selectedTableCells = tableUtils.getSelectedTableCells(model.document.selection);
+            // All cells will be merged into the first one.
+            const firstTableCell = selectedTableCells.shift();
+            // Update target cell dimensions.
+            const { mergeWidth, mergeHeight } = getMergeDimensions(firstTableCell, selectedTableCells, tableUtils);
+            updateNumericAttribute('colspan', mergeWidth, firstTableCell, writer);
+            updateNumericAttribute('rowspan', mergeHeight, firstTableCell, writer);
+            for (const tableCell of selectedTableCells) {
+                mergeTableCells(tableCell, firstTableCell, writer);
+            }
+            const table = firstTableCell.findAncestor('table');
+            // Remove rows and columns that become empty (have no anchored cells).
+            removeEmptyRowsColumns(table, tableUtils);
+            writer.setSelection(firstTableCell, 'in');
+        });
+    }
+}
+/**
+ *  Merges two table cells. It will ensure that after merging cells with empty paragraphs the resulting table cell will only have one
+ * paragraph. If one of the merged table cells is empty, the merged table cell will have contents of the non-empty table cell.
+ * If both are empty, the merged table cell will have only one empty paragraph.
+ */
+function mergeTableCells(cellBeingMerged, targetCell, writer) {
+    if (!isEmpty(cellBeingMerged)) {
+        if (isEmpty(targetCell)) {
+            writer.remove(writer.createRangeIn(targetCell));
+        }
+        writer.move(writer.createRangeIn(cellBeingMerged), writer.createPositionAt(targetCell, 'end'));
+    }
+    // Remove merged table cell.
+    writer.remove(cellBeingMerged);
+}
+/**
+ * Checks if the passed table cell contains an empty paragraph.
+ */
+function isEmpty(tableCell) {
+    const firstTableChild = tableCell.getChild(0);
+    return tableCell.childCount == 1 && firstTableChild.is('element', 'paragraph') && firstTableChild.isEmpty;
+}
+function getMergeDimensions(firstTableCell, selectedTableCells, tableUtils) {
+    let maxWidthOffset = 0;
+    let maxHeightOffset = 0;
+    for (const tableCell of selectedTableCells) {
+        const { row, column } = tableUtils.getCellLocation(tableCell);
+        maxWidthOffset = getMaxOffset(tableCell, column, maxWidthOffset, 'colspan');
+        maxHeightOffset = getMaxOffset(tableCell, row, maxHeightOffset, 'rowspan');
+    }
+    // Update table cell span attribute and merge set selection on a merged contents.
+    const { row: firstCellRow, column: firstCellColumn } = tableUtils.getCellLocation(firstTableCell);
+    const mergeWidth = maxWidthOffset - firstCellColumn;
+    const mergeHeight = maxHeightOffset - firstCellRow;
+    return { mergeWidth, mergeHeight };
+}
+function getMaxOffset(tableCell, start, currentMaxOffset, which) {
+    const dimensionValue = parseInt(tableCell.getAttribute(which) || '1');
+    return Math.max(currentMaxOffset, start + dimensionValue);
+}