@ckeditor/ckeditor5-table 0.0.0-nightly-next-20260127.0 → 0.0.0-nightly-20260128.0

package/{dist → src}/commands/mergecellscommand.d.ts

@@ -2,7 +2,7 @@
  * @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 '@ckeditor/ckeditor5-core';
+import { Command } from 'ckeditor5/src/core.js';
 /**
  * The merge cells command.
  *

package/src/commands/mergecellscommand.js

@@ -0,0 +1,94 @@
+/**
+ * @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/{dist → src}/commands/removecolumncommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/removecolumncommand
  */
-import { Command } from '@ckeditor/ckeditor5-core';
+import { Command } from 'ckeditor5/src/core.js';
 /**
  * The remove column command.
  *

package/src/commands/removecolumncommand.js

@@ -0,0 +1,109 @@
+/**
+ * @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/{dist → src}/commands/removerowcommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/removerowcommand
  */
-import { Command } from '@ckeditor/ckeditor5-core';
+import { Command } from 'ckeditor5/src/core.js';
 /**
  * The remove row command.
  *

package/src/commands/removerowcommand.js

@@ -0,0 +1,82 @@
+/**
+ * @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/{dist → src}/commands/selectcolumncommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/selectcolumncommand
  */
-import { Command, type Editor } from '@ckeditor/ckeditor5-core';
+import { Command, type Editor } from 'ckeditor5/src/core.js';
 /**
  * The select column command.
  *

package/src/commands/selectcolumncommand.js

@@ -0,0 +1,60 @@
+/**
+ * @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/{dist → src}/commands/selectrowcommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/selectrowcommand
  */
-import { Command, type Editor } from '@ckeditor/ckeditor5-core';
+import { Command, type Editor } from 'ckeditor5/src/core.js';
 /**
  * The select row command.
  *

package/src/commands/selectrowcommand.js

@@ -0,0 +1,56 @@
+/**
+ * @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);
+        });
+    }
+}

package/{dist → src}/commands/setheadercolumncommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/setheadercolumncommand
  */
-import { Command } from '@ckeditor/ckeditor5-core';
+import { Command } from 'ckeditor5/src/core.js';
 /**
  * The header column command.
  *

package/src/commands/setheadercolumncommand.js

@@ -0,0 +1,76 @@
+/**
+ * @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/setheadercolumncommand
+ */
+import { Command } from 'ckeditor5/src/core.js';
+import { isHeadingColumnCell } from '../utils/common.js';
+import { getHorizontallyOverlappingCells, splitVertically } from '../utils/structure.js';
+/**
+ * The header column command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'setTableColumnHeader'` editor command.
+ *
+ * You can make the column containing the selected cell a [header](https://www.w3.org/TR/html50/tabular-data.html#the-th-element)
+ * by executing:
+ *
+ * ```ts
+ * editor.execute( 'setTableColumnHeader' );
+ * ```
+ *
+ * **Note:** All preceding columns will also become headers. If the current column is already a header, executing this command
+ * will make it a regular column back again (including the following columns).
+ */
+export class SetHeaderColumnCommand extends Command {
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const model = this.editor.model;
+        const selectedCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
+        if (selectedCells.length === 0) {
+            this.isEnabled = false;
+            this.value = false;
+            return;
+        }
+        const table = selectedCells[0].findAncestor('table');
+        this.isEnabled = model.schema.checkAttribute(table, 'headingColumns');
+        this.value = selectedCells.every(cell => isHeadingColumnCell(tableUtils, cell));
+    }
+    /**
+     * Executes the command.
+     *
+     * When the selection is in a non-header column, the command will set the `headingColumns` table attribute to cover that column.
+     *
+     * When the selection is already in a header column, it will set `headingColumns` so the heading section will end before that column.
+     *
+     * @fires execute
+     * @param options.forceValue If set, the command will set (`true`) or unset (`false`) the header columns according to
+     * the `forceValue` parameter instead of the current model state.
+     */
+    execute(options = {}) {
+        if (options.forceValue === this.value) {
+            return;
+        }
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const model = this.editor.model;
+        const selectedCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
+        const table = selectedCells[0].findAncestor('table');
+        const { first, last } = tableUtils.getColumnIndexes(selectedCells);
+        const headingColumnsToSet = this.value ? first : last + 1;
+        model.change(writer => {
+            if (headingColumnsToSet) {
+                // Changing heading columns requires to check if any of a heading cell is overlapping horizontally the table head.
+                // Any table cell that has a colspan attribute > 1 will not exceed the table head so we need to fix it in columns before.
+                const overlappingCells = getHorizontallyOverlappingCells(table, headingColumnsToSet);
+                for (const { cell, column } of overlappingCells) {
+                    splitVertically(cell, column, headingColumnsToSet, writer);
+                }
+            }
+            tableUtils.setHeadingColumnsCount(writer, table, headingColumnsToSet);
+        });
+    }
+}

package/{dist → src}/commands/setheaderrowcommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/setheaderrowcommand
  */
-import { Command } from '@ckeditor/ckeditor5-core';
+import { Command } from 'ckeditor5/src/core.js';
 /**
  * The header row command.
  *

package/src/commands/setheaderrowcommand.js

@@ -0,0 +1,83 @@
+/**
+ * @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/setheaderrowcommand
+ */
+import { Command } from 'ckeditor5/src/core.js';
+import { getVerticallyOverlappingCells, splitHorizontally } from '../utils/structure.js';
+/**
+ * The header row command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'setTableColumnHeader'` editor command.
+ *
+ * You can make the row containing the selected cell a [header](https://www.w3.org/TR/html50/tabular-data.html#the-th-element) by executing:
+ *
+ * ```ts
+ * editor.execute( 'setTableRowHeader' );
+ * ```
+ *
+ * **Note:** All preceding rows will also become headers. If the current row is already a header, executing this command
+ * will make it a regular row back again (including the following rows).
+ */
+export class SetHeaderRowCommand extends Command {
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const model = this.editor.model;
+        const selectedCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
+        if (selectedCells.length === 0) {
+            this.isEnabled = false;
+            this.value = false;
+            return;
+        }
+        const table = selectedCells[0].findAncestor('table');
+        this.isEnabled = model.schema.checkAttribute(table, 'headingRows');
+        this.value = selectedCells.every(cell => this._isInHeading(cell, cell.parent.parent));
+    }
+    /**
+     * Executes the command.
+     *
+     * When the selection is in a non-header row, the command will set the `headingRows` table attribute to cover that row.
+     *
+     * When the selection is already in a header row, it will set `headingRows` so the heading section will end before that row.
+     *
+     * @fires execute
+     * @param options.forceValue If set, the command will set (`true`) or unset (`false`) the header rows according to
+     * the `forceValue` parameter instead of the current model state.
+     */
+    execute(options = {}) {
+        if (options.forceValue === this.value) {
+            return;
+        }
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const model = this.editor.model;
+        const selectedCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
+        const table = selectedCells[0].findAncestor('table');
+        const { first, last } = tableUtils.getRowIndexes(selectedCells);
+        const headingRowsToSet = this.value ? first : last + 1;
+        const currentHeadingRows = table.getAttribute('headingRows') || 0;
+        model.change(writer => {
+            if (headingRowsToSet) {
+                // Changing heading rows requires to check if any of a heading cell is overlapping vertically the table head.
+                // Any table cell that has a rowspan attribute > 1 will not exceed the table head so we need to fix it in rows below.
+                const startRow = headingRowsToSet > currentHeadingRows ? currentHeadingRows : 0;
+                const overlappingCells = getVerticallyOverlappingCells(table, headingRowsToSet, startRow);
+                for (const { cell } of overlappingCells) {
+                    splitHorizontally(cell, headingRowsToSet, writer);
+                }
+            }
+            tableUtils.setHeadingRowsCount(writer, table, headingRowsToSet);
+        });
+    }
+    /**
+     * Checks if a table cell is in the heading section.
+     */
+    _isInHeading(tableCell, table) {
+        const headingRows = parseInt(table.getAttribute('headingRows') || '0');
+        return !!headingRows && tableCell.parent.index < headingRows;
+    }
+}

package/{dist → src}/commands/splitcellcommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/splitcellcommand
  */
-import { Command, type Editor } from '@ckeditor/ckeditor5-core';
+import { Command, type Editor } from 'ckeditor5/src/core.js';
 /**
  * The split cell command.
  *