@ckeditor/ckeditor5-table 0.0.0-nightly-20260118.0 → 0.0.0-nightly-next-20260118.0

package/src/commands/mergecellcommand.js

@@ -1,206 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-import { Command } from 'ckeditor5/src/core.js';
-import { TableWalker } from '../tablewalker.js';
-import { isHeadingColumnCell } from '../utils/common.js';
-import { removeEmptyRowsColumns } from '../utils/structure.js';
-/**
- * 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 class MergeCellCommand extends Command {
-    /**
-     * The direction that indicates which cell will be merged with the currently selected one.
-     */
-    direction;
-    /**
-     * Whether the merge is horizontal (left/right) or vertical (up/down).
-     */
-    isHorizontal;
-    /**
-     * 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.js

@@ -1,94 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-import { Command } from 'ckeditor5/src/core.js';
-import { TableUtils } from '../tableutils.js';
-import { updateNumericAttribute } from '../utils/common.js';
-import { removeEmptyRowsColumns } from '../utils/structure.js';
-/**
- * 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 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);
-}

package/src/commands/removecolumncommand.js

@@ -1,109 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module table/commands/removecolumncommand
- */
-import { Command } from 'ckeditor5/src/core.js';
-import { TableWalker } from '../tablewalker.js';
-/**
- * The remove column command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'removeTableColumn'` editor command.
- *
- * To remove the column containing the selected cell, execute the command:
- *
- * ```ts
- * editor.execute( 'removeTableColumn' );
- * ```
- */
-export class RemoveColumnCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const selectedCells = tableUtils.getSelectionAffectedTableCells(this.editor.model.document.selection);
-        const firstCell = selectedCells[0];
-        if (firstCell) {
-            const table = firstCell.findAncestor('table');
-            const tableColumnCount = tableUtils.getColumns(table);
-            const { first, last } = tableUtils.getColumnIndexes(selectedCells);
-            this.isEnabled = last - first < (tableColumnCount - 1);
-        }
-        else {
-            this.isEnabled = false;
-        }
-    }
-    /**
-     * @inheritDoc
-     */
-    execute() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const [firstCell, lastCell] = getBoundaryCells(this.editor.model.document.selection, tableUtils);
-        const table = firstCell.parent.parent;
-        // Cache the table before removing or updating colspans.
-        const tableMap = [...new TableWalker(table)];
-        // Store column indexes of removed columns.
-        const removedColumnIndexes = {
-            first: tableMap.find(value => value.cell === firstCell).column,
-            last: tableMap.find(value => value.cell === lastCell).column
-        };
-        const cellToFocus = getCellToFocus(tableMap, firstCell, lastCell, removedColumnIndexes);
-        this.editor.model.change(writer => {
-            const columnsToRemove = removedColumnIndexes.last - removedColumnIndexes.first + 1;
-            tableUtils.removeColumns(table, {
-                at: removedColumnIndexes.first,
-                columns: columnsToRemove
-            });
-            writer.setSelection(writer.createPositionAt(cellToFocus, 0));
-        });
-    }
-}
-/**
- * Returns a proper table cell to focus after removing a column.
- * - selection is on last table cell it will return previous cell.
- */
-function getCellToFocus(tableMap, firstCell, lastCell, removedColumnIndexes) {
-    const colspan = parseInt(lastCell.getAttribute('colspan') || '1');
-    // If the table cell is spanned over 2+ columns - it will be truncated so the selection should
-    // stay in that cell.
-    if (colspan > 1) {
-        return lastCell;
-    }
-    // Normally, look for the cell in the same row that precedes the first cell to put selection there ("column on the left").
-    // If the deleted column is the first column of the table, there will be no predecessor: use the cell
-    // from the column that follows then (also in the same row).
-    else if (firstCell.previousSibling || lastCell.nextSibling) {
-        return lastCell.nextSibling || firstCell.previousSibling;
-    }
-    // It can happen that table cells have no siblings in a row, for instance, when there are row spans
-    // in the table (in the previous row). Then just look for the closest cell that is in a column
-    // that will not be removed to put the selection there.
-    else {
-        // Look for any cell in a column that precedes the first removed column.
-        if (removedColumnIndexes.first) {
-            return tableMap.reverse().find(({ column }) => {
-                return column < removedColumnIndexes.first;
-            }).cell;
-        }
-        // If the first removed column is the first column of the table, then
-        // look for any cell that is in a column that follows the last removed column.
-        else {
-            return tableMap.reverse().find(({ column }) => {
-                return column > removedColumnIndexes.last;
-            }).cell;
-        }
-    }
-}
-/**
- * Returns helper object returning the first and the last cell contained in given selection, based on DOM order.
- */
-function getBoundaryCells(selection, tableUtils) {
-    const referenceCells = tableUtils.getSelectionAffectedTableCells(selection);
-    const firstCell = referenceCells[0];
-    const lastCell = referenceCells.pop();
-    const returnValue = [firstCell, lastCell];
-    return firstCell.isBefore(lastCell) ? returnValue : returnValue.reverse();
-}

package/src/commands/removerowcommand.js

@@ -1,82 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module table/commands/removerowcommand
- */
-import { Command } from 'ckeditor5/src/core.js';
-/**
- * The remove row command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'removeTableRow'` editor command.
- *
- * To remove the row containing the selected cell, execute the command:
- *
- * ```ts
- * editor.execute( 'removeTableRow' );
- * ```
- */
-export class RemoveRowCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const selectedCells = tableUtils.getSelectionAffectedTableCells(this.editor.model.document.selection);
-        const firstCell = selectedCells[0];
-        if (firstCell) {
-            const table = firstCell.findAncestor('table');
-            const tableRowCount = tableUtils.getRows(table);
-            const lastRowIndex = tableRowCount - 1;
-            const selectedRowIndexes = tableUtils.getRowIndexes(selectedCells);
-            const areAllRowsSelected = selectedRowIndexes.first === 0 && selectedRowIndexes.last === lastRowIndex;
-            // Disallow selecting whole table -> delete whole table should be used instead.
-            this.isEnabled = !areAllRowsSelected;
-        }
-        else {
-            this.isEnabled = false;
-        }
-    }
-    /**
-     * @inheritDoc
-     */
-    execute() {
-        const model = this.editor.model;
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const referenceCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
-        const removedRowIndexes = tableUtils.getRowIndexes(referenceCells);
-        const firstCell = referenceCells[0];
-        const table = firstCell.findAncestor('table');
-        const columnIndexToFocus = tableUtils.getCellLocation(firstCell).column;
-        model.change(writer => {
-            const rowsToRemove = removedRowIndexes.last - removedRowIndexes.first + 1;
-            tableUtils.removeRows(table, {
-                at: removedRowIndexes.first,
-                rows: rowsToRemove
-            });
-            const cellToFocus = getCellToFocus(table, removedRowIndexes.first, columnIndexToFocus, tableUtils.getRows(table));
-            writer.setSelection(writer.createPositionAt(cellToFocus, 0));
-        });
-    }
-}
-/**
- * Returns a cell that should be focused before removing the row, belonging to the same column as the currently focused cell.
- * - If the row was not the last one, the cell to focus will be in the row that followed it (before removal).
- * - If the row was the last one, the cell to focus will be in the row that preceded it (before removal).
- */
-function getCellToFocus(table, removedRowIndex, columnToFocus, tableRowCount) {
-    // Don't go beyond last row's index.
-    const row = table.getChild(Math.min(removedRowIndex, tableRowCount - 1));
-    // Default to first table cell.
-    let cellToFocus = row.getChild(0);
-    let column = 0;
-    for (const tableCell of row.getChildren()) {
-        if (column > columnToFocus) {
-            return cellToFocus;
-        }
-        cellToFocus = tableCell;
-        column += parseInt(tableCell.getAttribute('colspan') || '1');
-    }
-    return cellToFocus;
-}

package/src/commands/selectcolumncommand.js

@@ -1,60 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module table/commands/selectcolumncommand
- */
-import { Command } from 'ckeditor5/src/core.js';
-import { TableWalker } from '../tablewalker.js';
-/**
- * The select column command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'selectTableColumn'` editor command.
- *
- * To select the columns containing the selected cells, execute the command:
- *
- * ```ts
- * editor.execute( 'selectTableColumn' );
- * ```
- */
-export class SelectColumnCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    constructor(editor) {
-        super(editor);
-        // It does not affect data so should be enabled in read-only mode.
-        this.affectsData = false;
-    }
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const selectedCells = tableUtils.getSelectionAffectedTableCells(this.editor.model.document.selection);
-        this.isEnabled = selectedCells.length > 0;
-    }
-    /**
-     * @inheritDoc
-     */
-    execute() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const model = this.editor.model;
-        const referenceCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
-        const firstCell = referenceCells[0];
-        const lastCell = referenceCells.pop();
-        const table = firstCell.findAncestor('table');
-        const startLocation = tableUtils.getCellLocation(firstCell);
-        const endLocation = tableUtils.getCellLocation(lastCell);
-        const startColumn = Math.min(startLocation.column, endLocation.column);
-        const endColumn = Math.max(startLocation.column, endLocation.column);
-        const rangesToSelect = [];
-        for (const cellInfo of new TableWalker(table, { startColumn, endColumn })) {
-            rangesToSelect.push(model.createRangeOn(cellInfo.cell));
-        }
-        model.change(writer => {
-            writer.setSelection(rangesToSelect);
-        });
-    }
-}

package/src/commands/selectrowcommand.js

@@ -1,56 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module table/commands/selectrowcommand
- */
-import { Command } from 'ckeditor5/src/core.js';
-/**
- * The select row command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'selectTableRow'` editor command.
- *
- * To select the rows containing the selected cells, execute the command:
- *
- * ```ts
- * editor.execute( 'selectTableRow' );
- * ```
- */
-export class SelectRowCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    constructor(editor) {
-        super(editor);
-        // It does not affect data so should be enabled in read-only mode.
-        this.affectsData = false;
-    }
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const selectedCells = tableUtils.getSelectionAffectedTableCells(this.editor.model.document.selection);
-        this.isEnabled = selectedCells.length > 0;
-    }
-    /**
-     * @inheritDoc
-     */
-    execute() {
-        const model = this.editor.model;
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const referenceCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
-        const rowIndexes = tableUtils.getRowIndexes(referenceCells);
-        const table = referenceCells[0].findAncestor('table');
-        const rangesToSelect = [];
-        for (let rowIndex = rowIndexes.first; rowIndex <= rowIndexes.last; rowIndex++) {
-            for (const cell of table.getChild(rowIndex).getChildren()) {
-                rangesToSelect.push(model.createRangeOn(cell));
-            }
-        }
-        model.change(writer => {
-            writer.setSelection(rangesToSelect);
-        });
-    }
-}