@ckeditor/ckeditor5-table 0.0.0-nightly-next-20260108.0 → 0.0.0-nightly-20260109.0

package/src/converters/upcasttable.js

@@ -0,0 +1,385 @@
+/**
+ * @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 { createEmptyTableCell } from '../utils/common.js';
+import { getViewTableFromWrapper } from '../utils/structure.js';
+import { first } from 'ckeditor5/src/utils.js';
+/**
+ * Returns a function that converts the table view representation:
+ *
+ * ```xml
+ * <figure class="table"><table>...</table></figure>
+ * ```
+ *
+ * to the model representation:
+ *
+ * ```xml
+ * <table></table>
+ * ```
+ *
+ * @internal
+ */
+export function upcastTableFigure() {
+    return (dispatcher) => {
+        dispatcher.on('element:figure', (evt, data, conversionApi) => {
+            // Do not convert if this is not a "table figure".
+            if (!conversionApi.consumable.test(data.viewItem, { name: true, classes: 'table' })) {
+                return;
+            }
+            // Find a table element inside the figure element.
+            const viewTable = getViewTableFromWrapper(data.viewItem);
+            // Do not convert if table element is absent or was already converted.
+            if (!viewTable || !conversionApi.consumable.test(viewTable, { name: true })) {
+                return;
+            }
+            // Consume the figure to prevent other converters from processing it again.
+            conversionApi.consumable.consume(data.viewItem, { name: true, classes: 'table' });
+            // Convert view table to model table.
+            const conversionResult = conversionApi.convertItem(viewTable, data.modelCursor);
+            // Get table element from conversion result.
+            const modelTable = first(conversionResult.modelRange.getItems());
+            // When table wasn't successfully converted then finish conversion.
+            if (!modelTable || !modelTable.is('element', 'table')) {
+                // Revert consumed figure so other features can convert it.
+                conversionApi.consumable.revert(data.viewItem, { name: true, classes: 'table' });
+                // If anyway some table content was converted, we have to pass the model range and cursor.
+                if (conversionResult.modelRange && !conversionResult.modelRange.isCollapsed) {
+                    data.modelRange = conversionResult.modelRange;
+                    data.modelCursor = conversionResult.modelCursor;
+                }
+                return;
+            }
+            conversionApi.convertChildren(data.viewItem, conversionApi.writer.createPositionAt(modelTable, 'end'));
+            conversionApi.updateConversionResult(modelTable, data);
+        });
+    };
+}
+/**
+ * View table element to model table element conversion helper.
+ *
+ * This conversion helper converts the table element as well as table rows.
+ *
+ * @returns Conversion helper.
+ * @internal
+ */
+export function upcastTable() {
+    return (dispatcher) => {
+        dispatcher.on('element:table', (evt, data, conversionApi) => {
+            const viewTable = data.viewItem;
+            // When element was already consumed then skip it.
+            if (!conversionApi.consumable.test(viewTable, { name: true })) {
+                return;
+            }
+            const { rows, headingRows, headingColumns } = scanTable(viewTable);
+            // Only set attributes if values is greater then 0.
+            const attributes = {};
+            if (headingColumns) {
+                attributes.headingColumns = headingColumns;
+            }
+            if (headingRows) {
+                attributes.headingRows = headingRows;
+            }
+            const table = conversionApi.writer.createElement('table', attributes);
+            if (!conversionApi.safeInsert(table, data.modelCursor)) {
+                return;
+            }
+            conversionApi.consumable.consume(viewTable, { name: true });
+            // Upcast table rows in proper order (heading rows first).
+            rows.forEach(row => conversionApi.convertItem(row, conversionApi.writer.createPositionAt(table, 'end')));
+            // Convert everything else.
+            conversionApi.convertChildren(viewTable, conversionApi.writer.createPositionAt(table, 'end'));
+            // Create one row and one table cell for empty table.
+            if (table.isEmpty) {
+                const row = conversionApi.writer.createElement('tableRow');
+                conversionApi.writer.insert(row, conversionApi.writer.createPositionAt(table, 'end'));
+                createEmptyTableCell(conversionApi.writer, conversionApi.writer.createPositionAt(row, 'end'));
+            }
+            conversionApi.updateConversionResult(table, data);
+        });
+    };
+}
+/**
+ * A conversion helper that skips empty <tr> elements from upcasting at the beginning of the table.
+ *
+ * An empty row is considered a table model error but when handling clipboard data there could be rows that contain only row-spanned cells
+ * and empty TR-s are used to maintain the table structure (also {@link module:table/tablewalker~TableWalker} assumes that there are only
+ * rows that have related `tableRow` elements).
+ *
+ * *Note:* Only the first empty rows are removed because they have no meaning and it solves the issue
+ * of an improper table with all empty rows.
+ *
+ * @internal
+ * @returns Conversion helper.
+ */
+export function skipEmptyTableRow() {
+    return (dispatcher) => {
+        dispatcher.on('element:tr', (evt, data) => {
+            if (data.viewItem.isEmpty && data.modelCursor.index == 0) {
+                evt.stop();
+            }
+        }, { priority: 'high' });
+    };
+}
+/**
+ * A converter that ensures an empty paragraph is inserted in a table cell if no other content was converted.
+ *
+ * @internal
+ * @returns Conversion helper.
+ */
+export function ensureParagraphInTableCell(elementName) {
+    return (dispatcher) => {
+        dispatcher.on(`element:${elementName}`, (evt, data, { writer }) => {
+            // The default converter will create a model range on converted table cell.
+            if (!data.modelRange) {
+                return;
+            }
+            const tableCell = data.modelRange.start.nodeAfter;
+            const modelCursor = writer.createPositionAt(tableCell, 0);
+            // Ensure a paragraph in the model for empty table cells for converted table cells.
+            if (data.viewItem.isEmpty) {
+                writer.insertElement('paragraph', modelCursor);
+                return;
+            }
+            const childNodes = Array.from(tableCell.getChildren());
+            // In case there are only markers inside the table cell then move them to the paragraph.
+            if (childNodes.every(node => node.is('element', '$marker'))) {
+                const paragraph = writer.createElement('paragraph');
+                writer.insert(paragraph, writer.createPositionAt(tableCell, 0));
+                for (const node of childNodes) {
+                    writer.move(writer.createRangeOn(node), writer.createPositionAt(paragraph, 'end'));
+                }
+            }
+        }, { priority: 'low' });
+    };
+}
+/**
+ * Scans table rows and extracts required metadata from the table:
+ *
+ * headingRows    - The number of rows that go as table headers.
+ * headingColumns - The maximum number of row headings.
+ * rows           - Sorted `<tr>` elements as they should go into the model - ie. if `<thead>` is inserted after `<tbody>` in the view.
+ *
+ * @param viewTable The view table element.
+ * @returns The table metadata.
+ */
+function scanTable(viewTable) {
+    let headingColumns = undefined;
+    let shouldAccumulateHeadingRows = true;
+    // The `<tbody>` and `<thead>` sections in the DOM do not have to be in order `<thead>` -> `<tbody>` and there might be more than one
+    // of them.
+    // As the model does not have these sections, rows from different sections must be sorted.
+    // For example, below is a valid HTML table:
+    //
+    // <table>
+    //   <tbody><tr><td>2</td></tr></tbody>
+    //   <thead><tr><td>1</td></tr></thead>
+    //   <tbody><tr><td>3</td></tr></tbody>
+    // </table>
+    //
+    // But browsers will render rows in order as: 1 as the heading and 2 and 3 as the body.
+    const headRows = [];
+    const bodyRows = [];
+    // Currently the editor does not support more then one <thead> section.
+    // Only the first <thead> from the view will be used as a heading row and the others will be converted to body rows.
+    let firstTheadElement;
+    for (const tableChild of Array.from(viewTable.getChildren())) {
+        // Only `<thead>`, `<tbody>` & `<tfoot>` from allowed table children can have `<tr>`s.
+        // The else is for future purposes (mainly `<caption>`).
+        if (tableChild.name !== 'tbody' && tableChild.name !== 'thead' && tableChild.name !== 'tfoot') {
+            continue;
+        }
+        // Save the first `<thead>` in the table as table header - all other ones will be converted to table body rows.
+        if (tableChild.name === 'thead' && !firstTheadElement) {
+            shouldAccumulateHeadingRows = true;
+            firstTheadElement = tableChild;
+        }
+        // There might be some extra empty text nodes between the `<tr>`s.
+        // Make sure further code operates on `tr`s only. (#145)
+        const trs = Array.from(tableChild.getChildren()).filter((el) => el.is('element', 'tr'));
+        // Keep tracking of the previous row columns count to improve detection of heading rows.
+        let maxPrevColumns = null;
+        for (const tr of trs) {
+            const trColumns = Array
+                .from(tr.getChildren())
+                .filter(el => el.is('element', 'td') || el.is('element', 'th'));
+            // This <tr> is a child of a first <thead> element.
+            if ((firstTheadElement && tableChild === firstTheadElement) ||
+                (tableChild.name === 'tbody' &&
+                    trColumns.length > 0 &&
+                    // These conditions handles the case when the first column is a <th> element and it's the only column in the row.
+                    // This case is problematic because it's not clear if this row should be a heading row or not, as it may be result
+                    // of the cell span from the previous row.
+                    // Issue: https://github.com/ckeditor/ckeditor5/issues/17556
+                    (maxPrevColumns === null || trColumns.length === maxPrevColumns) &&
+                    trColumns.every(e => e.is('element', 'th')) &&
+                    // If there is at least one "normal" table row between heading rows, then stop accumulating heading rows.
+                    shouldAccumulateHeadingRows)) {
+                headRows.push(tr);
+                shouldAccumulateHeadingRows = true;
+            }
+            else {
+                bodyRows.push(tr);
+                shouldAccumulateHeadingRows = false;
+            }
+            // We use the maximum number of columns to avoid false positives when detecting
+            // multiple rows with single column within `rowspan`. Without it the last row of `rowspan=3`
+            // would be detected as a heading row because it has only one column (identical to the previous row).
+            maxPrevColumns = Math.max(maxPrevColumns || 0, trColumns.length);
+        }
+    }
+    // Generate the cell matrix so we can calculate the heading columns.
+    const bodyMatrix = generateCellMatrix(bodyRows);
+    for (const rowSlots of bodyMatrix) {
+        // Look for the first non-`<th>` entry (either a `<td>` or a missing cell).
+        let index = 0;
+        while (index < rowSlots.length) {
+            if (rowSlots[index]?.name !== 'th') {
+                break;
+            }
+            index += 1;
+        }
+        // Update headingColumns.
+        if (headingColumns === undefined || index < headingColumns) {
+            headingColumns = index;
+        }
+    }
+    return {
+        headingRows: headRows.length,
+        headingColumns: headingColumns || 0,
+        rows: [...headRows, ...bodyRows]
+    };
+}
+/**
+ * Takes an array of `<tr>` elements and generates a "matrix" (square
+ * two-dimensional array) describing which `<th>`s and `<td>`s fill which
+ * "slots", factoring in `rowspan`s and `colspan`s. For example, given
+ *
+ * ```xml
+ * <table>
+ *   <tr> <td>11</td> <td rowspan="2">12-22</td> <td>13</td> </tr>
+ *   <tr> <td>21</td> <td>23</td> </tr>
+ *   <tr> <td colspan="2">31-32</td> <td>33</rd> </tr>
+ * </table>
+ * ```
+ *
+ * The result would be (with cell elements' text content in place of the element
+ * objects for readability):
+ *
+ * ```js
+ * [
+ *   [ '11', '12-22', '13' ],
+ *   [ '21', '12-22', '23' ],
+ *   [ '31-32', '31-32', '33' ],
+ * ]
+ * ```
+ *
+ * This allows for a computation of heading columns that factors in the case
+ * where a cell from a previous rows with a `rowspan` attribute effectively adds
+ * an additional header cell to a subsequent row.
+ *
+ * There are also cases where cells are "missing" from a row. A simple one is
+ * the case where a row simply has fewer cells than another row in the same
+ * table. But another is one where a row has a cell with a `rowspan` that
+ * effectively adds a cell to a subsequent row "off the end" of the row. In this
+ * case, there will be a `null` value instead of an element object in that
+ * position. For example,
+ *
+ * ```xml
+ * <table>
+ *   <tr> <td>11</td> <td>12</td> <td rowspan="2">13-23</td> </tr>
+ *   <tr> <td>21</td> </tr>
+ *   <tr> <td>31</td> </tr>
+ * </table>
+ * ```
+ *
+ * would result in
+ *
+ * ```js
+ * [
+ *   [ '11', '12', '13-23' ],
+ *   [ '21', null, '13-23' ],
+ *   [ '31', null, null ]
+ * ]
+ * ```
+ *
+ * @param trs the array of `<tr>` elements
+ * @returns the cell matrix
+ */
+function generateCellMatrix(trs) {
+    // As we iterate, we keep track of cells with rowspans >1 so later rows can
+    // factor them in. This trackes any such cells from previous rows.
+    let prevRowspans = new Map();
+    // This is the maximum number of columns we've encountered.
+    let maxColumns = 0;
+    const slots = trs.map(tr => {
+        // This will be the slots that are in this row, including cells from
+        // previous rows with a big enough "rowspan" to affect this row.
+        const curSlots = [];
+        // Get the cell elements
+        const children = Array.from(tr.getChildren())
+            .filter(child => child.name === 'th' || child.name === 'td');
+        // This will be any cells in this row that have a rowspan >1, so we can
+        // combine it with `prevRowspans` when we're done processing this row.
+        const curRowspans = new Map();
+        // We need to process all the cells in this row, but also previous rows'
+        // cells with rowspans might add additional slots to the end of this row, so
+        // we need to iterate until we've both consumed all the children _and_
+        // filled out slots to the max number of columns we've encountered so far.
+        while (children.length || curSlots.length < maxColumns) {
+            const rowSpan = prevRowspans.get(curSlots.length);
+            if (rowSpan && rowSpan.remaining > 0) {
+                // We have a cell at this index in a previous row whose rowspan extends
+                // it into this row, so we insert a copy of it here.
+                curSlots.push(rowSpan.cell);
+            }
+            else {
+                // See if we have more cells in the row.
+                const cell = children.shift();
+                if (cell) {
+                    // We do, so process it
+                    const colspan = parseInt(cell.getAttribute('colspan') || '1');
+                    const rowspan = parseInt(cell.getAttribute('rowspan') || '1');
+                    // Process this cell as many times as needed according to its colspan.
+                    for (let i = 0; i < colspan; i++) {
+                        // if we have a >1 rowspan, create a record in the rowSpans map for
+                        // this column index keeping track of it.
+                        if (rowspan > 1) {
+                            curRowspans.set(curSlots.length, { cell, remaining: rowspan - 1 });
+                        }
+                        curSlots.push(cell);
+                    }
+                }
+                else {
+                    // No remaining children in this row, so no cell in this slot.
+                    curSlots.push(null);
+                    continue;
+                }
+            }
+        }
+        // Now update the row spans. In weird edge cases where colspan and rowspan
+        // conflict, we can end up with a cell in a column in this row that
+        // "truncates" a row-spanning cell from a previous column, so make sure in
+        // those cases, the value in `curRowspans` always "wins". We do this by
+        // copying (and decrementing) values from `prevRowspans` into `curRowspans`
+        // as long as there is no conflict, and then re-assigning `prevRowspans`.
+        for (const [index, entry] of prevRowspans.entries()) {
+            entry.remaining -= 1;
+            if (entry.remaining > 0 && !curRowspans.has(index)) {
+                curRowspans.set(index, entry);
+            }
+        }
+        prevRowspans = curRowspans;
+        // Finally, update `maxColumns`.
+        maxColumns = Math.max(maxColumns, curSlots.length);
+        return curSlots;
+    });
+    // Now expand any rows that have fewer than `maxColumns` with nulls so we have
+    // a proper matrix.
+    for (const rowSlots of slots) {
+        while (rowSlots.length < maxColumns) {
+            rowSlots.push(null);
+        }
+    }
+    return slots;
+}

package/{dist → src}/index.d.ts

@@ -1,7 +1,3 @@
-/**
- * @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
- */
 /**
  * @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
@@ -38,6 +34,10 @@ export { TableUtils, type TableIndexesObject } from './tableutils.js';
 export { TableColumnResize } from './tablecolumnresize.js';
 export { TableColumnResizeEditing } from './tablecolumnresize/tablecolumnresizeediting.js';
 export { TableWidthsCommand, type TableWidthsCommandOptions } from './tablecolumnresize/tablewidthscommand.js';
+export { TablePropertiesUIExperimental } from './tableproperties/tablepropertiesuiexperimental.js';
+export { TablePropertiesViewExperimental, type TablePropertiesViewOptionsExperimental } from './tableproperties/ui/tablepropertiesviewexperimental.js';
+export { TableCellPropertiesUIExperimental } from './tablecellproperties/tablecellpropertiesuiexperimental.js';
+export { TableCellPropertiesViewExperimental, type TableCellPropertiesViewOptionsExperimental } from './tablecellproperties/ui/tablecellpropertiesviewexperimental.js';
 export { InsertColumnCommand } from './commands/insertcolumncommand.js';
 export { InsertRowCommand } from './commands/insertrowcommand.js';
 export { InsertTableCommand } from './commands/inserttablecommand.js';
@@ -70,8 +70,7 @@ export { TableBorderWidthCommand } from './tableproperties/commands/tableborderw
 export { TableHeightCommand } from './tableproperties/commands/tableheightcommand.js';
 export { TableWidthCommand } from './tableproperties/commands/tablewidthcommand.js';
 export { TablePropertyCommand, type TablePropertyCommandExecuteOptions } from './tableproperties/commands/tablepropertycommand.js';
-export { TableCellTypeCommand } from './tablecellproperties/commands/tablecelltypecommand.js';
-export { isTableHeaderCellType, type TableCellType } from './tablecellproperties/tablecellpropertiesutils.js';
+export { TableCellTypeCommand, type TableCellType } from './tablecellproperties/commands/tablecelltypecommand.js';
 export { TableCellPropertyCommand, type TableCellPropertyCommandAfterExecuteEvent, type TableCellPropertyCommandAfterExecuteEventData } from './tablecellproperties/commands/tablecellpropertycommand.js';
 export type { ViewDocumentTableMouseMoveEvent, ViewDocumentTableMouseLeaveEvent } from './tablemouse/mouseeventsobserver.js';
 export type { TableConfig, TableAlignmentConfig, TablePropertiesConfig, TablePropertiesOptions, TableCellPropertiesConfig, TableColorConfig, TableCellPropertiesOptions, TableLayoutConfig, TableCaptionConfig, TableType } from './tableconfig.js';

package/src/index.js

@@ -0,0 +1,98 @@
+/**
+ * @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
+ */
+export { PlainTableOutput } from './plaintableoutput.js';
+export { Table } from './table.js';
+export { TableWalker } from './tablewalker.js';
+export { TableEditing } from './tableediting.js';
+export { TableUI } from './tableui.js';
+export { TableToolbar } from './tabletoolbar.js';
+export { TableCellProperties } from './tablecellproperties.js';
+export { TableCellPropertiesEditing } from './tablecellproperties/tablecellpropertiesediting.js';
+export { TableCellPropertiesUI } from './tablecellproperties/tablecellpropertiesui.js';
+export { TableCellPropertiesView } from './tablecellproperties/ui/tablecellpropertiesview.js';
+export { TableCellWidthEditing } from './tablecellwidth/tablecellwidthediting.js';
+export { TableLayout } from './tablelayout.js';
+export { TableLayoutEditing } from './tablelayout/tablelayoutediting.js';
+export { TableLayoutUI } from './tablelayout/tablelayoutui.js';
+export { TableProperties } from './tableproperties.js';
+export { TablePropertiesEditing } from './tableproperties/tablepropertiesediting.js';
+export { TablePropertiesUI } from './tableproperties/tablepropertiesui.js';
+export { TablePropertiesView } from './tableproperties/ui/tablepropertiesview.js';
+export { TableCaption } from './tablecaption.js';
+export { TableCaptionEditing } from './tablecaption/tablecaptionediting.js';
+export { TableCaptionUI } from './tablecaption/tablecaptionui.js';
+export { TableClipboard } from './tableclipboard.js';
+export { TableMouse } from './tablemouse.js';
+export { TableKeyboard } from './tablekeyboard.js';
+export { TableSelection } from './tableselection.js';
+export { TableUtils } from './tableutils.js';
+export { TableColumnResize } from './tablecolumnresize.js';
+export { TableColumnResizeEditing } from './tablecolumnresize/tablecolumnresizeediting.js';
+export { TableWidthsCommand } from './tablecolumnresize/tablewidthscommand.js';
+// [experimental] Remove in the v48.
+export { TablePropertiesUIExperimental } from './tableproperties/tablepropertiesuiexperimental.js';
+export { TablePropertiesViewExperimental } from './tableproperties/ui/tablepropertiesviewexperimental.js';
+export { TableCellPropertiesUIExperimental } from './tablecellproperties/tablecellpropertiesuiexperimental.js';
+export { TableCellPropertiesViewExperimental } from './tablecellproperties/ui/tablecellpropertiesviewexperimental.js';
+export { InsertColumnCommand } from './commands/insertcolumncommand.js';
+export { InsertRowCommand } from './commands/insertrowcommand.js';
+export { InsertTableCommand } from './commands/inserttablecommand.js';
+export { InsertTableLayoutCommand } from './commands/inserttablelayoutcommand.js';
+export { TableTypeCommand } from './tablelayout/commands/tabletypecommand.js';
+export { MergeCellCommand } from './commands/mergecellcommand.js';
+export { MergeCellsCommand } from './commands/mergecellscommand.js';
+export { RemoveColumnCommand } from './commands/removecolumncommand.js';
+export { RemoveRowCommand } from './commands/removerowcommand.js';
+export { SelectColumnCommand } from './commands/selectcolumncommand.js';
+export { SelectRowCommand } from './commands/selectrowcommand.js';
+export { SetHeaderColumnCommand } from './commands/setheadercolumncommand.js';
+export { SetHeaderRowCommand } from './commands/setheaderrowcommand.js';
+export { SplitCellCommand } from './commands/splitcellcommand.js';
+export { ToggleTableCaptionCommand } from './tablecaption/toggletablecaptioncommand.js';
+export { TableCellBackgroundColorCommand } from './tablecellproperties/commands/tablecellbackgroundcolorcommand.js';
+export { TableCellBorderColorCommand } from './tablecellproperties/commands/tablecellbordercolorcommand.js';
+export { TableCellBorderStyleCommand } from './tablecellproperties/commands/tablecellborderstylecommand.js';
+export { TableCellBorderWidthCommand } from './tablecellproperties/commands/tablecellborderwidthcommand.js';
+export { TableCellHeightCommand } from './tablecellproperties/commands/tablecellheightcommand.js';
+export { TableCellHorizontalAlignmentCommand } from './tablecellproperties/commands/tablecellhorizontalalignmentcommand.js';
+export { TableCellPaddingCommand } from './tablecellproperties/commands/tablecellpaddingcommand.js';
+export { TableCellVerticalAlignmentCommand } from './tablecellproperties/commands/tablecellverticalalignmentcommand.js';
+export { TableCellWidthCommand } from './tablecellwidth/commands/tablecellwidthcommand.js';
+export { TableAlignmentCommand } from './tableproperties/commands/tablealignmentcommand.js';
+export { TableBackgroundColorCommand } from './tableproperties/commands/tablebackgroundcolorcommand.js';
+export { TableBorderColorCommand } from './tableproperties/commands/tablebordercolorcommand.js';
+export { TableBorderStyleCommand } from './tableproperties/commands/tableborderstylecommand.js';
+export { TableBorderWidthCommand } from './tableproperties/commands/tableborderwidthcommand.js';
+export { TableHeightCommand } from './tableproperties/commands/tableheightcommand.js';
+export { TableWidthCommand } from './tableproperties/commands/tablewidthcommand.js';
+export { TablePropertyCommand } from './tableproperties/commands/tablepropertycommand.js';
+export { TableCellTypeCommand } from './tablecellproperties/commands/tablecelltypecommand.js';
+export { TableCellPropertyCommand } from './tablecellproperties/commands/tablecellpropertycommand.js';
+// Internal exports.
+export { downcastTable as _downcastTable, downcastRow as _downcastTableRow, downcastCell as _downcastTableCell, convertParagraphInTableCell as _convertParagraphInTableCell, isSingleParagraphWithoutAttributes as _isSingleTableParagraphWithoutAttributes } from './converters/downcast.js';
+export { injectTableCaptionPostFixer as _injectTableCaptionPostFixer } from './converters/table-caption-post-fixer.js';
+export { injectTableCellParagraphPostFixer as _injectTableCellParagraphPostFixer } from './converters/table-cell-paragraph-post-fixer.js';
+export { tableCellRefreshHandler as _tableCellRefreshHandler } from './converters/table-cell-refresh-handler.js';
+export { tableHeadingsRefreshHandler as _tableHeadingsRefreshHandler } from './converters/table-headings-refresh-handler.js';
+export { injectTableLayoutPostFixer as _injectTableLayoutPostFixer } from './converters/table-layout-post-fixer.js';
+export { upcastStyleToAttribute as _upcastNormalizedTableStyleToAttribute, upcastBorderStyles as _upcastTableBorderStyles, downcastAttributeToStyle as _downcastTableAttributeToStyle, downcastTableAttribute as _downcastTableAttribute, getDefaultValueAdjusted as _getDefaultTableValueAdjusted } from './converters/tableproperties.js';
+export { upcastTableFigure as _upcastTableFigure, upcastTable as _upcastTable, skipEmptyTableRow as _skipEmptyTableRow, ensureParagraphInTableCell as _ensureParagraphInTableCell } from './converters/upcasttable.js';
+export { isTable as _isTableModelElement, getCaptionFromTableModelElement as _getTableCaptionFromModelElement, getCaptionFromModelSelection as _getTableCaptionFromModelSelection, matchTableCaptionViewElement as _matchTableCaptionViewElement } from './tablecaption/utils.js';
+export { COLUMN_MIN_WIDTH_AS_PERCENTAGE as _TABLE_COLUMN_MIN_WIDTH_AS_PERCENTAGE, COLUMN_MIN_WIDTH_IN_PIXELS as _TABLE_COLUMN_MIN_WIDTH_IN_PIXELS, COLUMN_WIDTH_PRECISION as _TABLE_COLUMN_WIDTH_PRECISION, COLUMN_RESIZE_DISTANCE_THRESHOLD as _TABLE_COLUMN_RESIZE_DISTANCE_THRESHOLD } from './tablecolumnresize/constants.js';
+export { upcastColgroupElement as _upcastTableColgroupElement, downcastTableResizedClass as _downcastTableResizedClass } from './tablecolumnresize/converters.js';
+export { getChangedResizedTables as _getChangedResizedTables, getColumnMinWidthAsPercentage as _getTableColumnMinWidthAsPercentage, getTableWidthInPixels as _getTableWidthInPixels, getElementWidthInPixels as _getElementWidthInPixels, getColumnEdgesIndexes as _getTableColumnEdgesIndexes, toPrecision as _toPrecision, clamp as _clamp, createFilledArray as _createFilledArray, sumArray as _sumArray, normalizeColumnWidths as _normalizeTableColumnWidths, getDomCellOuterWidth as _getDomTableCellOuterWidth, updateColumnElements as _updateTableColumnElements, getColumnGroupElement as _getTableColumnGroupElement, getTableColumnElements as _getTableColumnElements, getTableColumnsWidths as _getTableColumnsWidths, translateColSpanAttribute as _translateTableColspanAttribute } from './tablecolumnresize/utils.js';
+export { MouseEventsObserver as _TableMouseEventsObserver } from './tablemouse/mouseeventsobserver.js';
+export { ColorInputView as _TableColorInputView } from './ui/colorinputview.js';
+export { InsertTableView as _InsertTableView } from './ui/inserttableview.js';
+export { updateNumericAttribute as _updateTableNumericAttribute, createEmptyTableCell as _createEmptyTableCell, isHeadingColumnCell as _isTableHeadingColumnCell, enableProperty as _enableTableCellProperty, getSelectionAffectedTable as _getSelectionAffectedTable } from './utils/common.js';
+export { cropTableToDimensions as _cropTableToDimensions, getVerticallyOverlappingCells as _getVerticallyOverlappingTableCells, splitHorizontally as _splitTableCellHorizontally, getHorizontallyOverlappingCells as _getHorizontallyOverlappingTableCells, splitVertically as _splitTableCellVertically, trimTableCellIfNeeded as _trimTableCellIfNeeded, removeEmptyColumns as _removeEmptyTableColumns, removeEmptyRows as _removeEmptyTableRows, removeEmptyRowsColumns as _removeEmptyTableRowsColumns, adjustLastRowIndex as _adjustLastTableRowIndex, adjustLastColumnIndex as _adjustLastTableColumnIndex } from './utils/structure.js';
+export { getSingleValue as _getTableBorderBoxSingleValue, addDefaultUnitToNumericValue as _addDefaultUnitToNumericValue, getNormalizedDefaultProperties as _getNormalizedDefaultTableBaseProperties, getNormalizedDefaultTableProperties as _getNormalizedDefaultTableProperties, getNormalizedDefaultCellProperties as _getNormalizedDefaultTableCellProperties } from './utils/table-properties.js';
+export { repositionContextualBalloon as _repositionTableContextualBalloon, getBalloonTablePositionData as _getBalloonTablePositionData, getBalloonCellPositionData as _getBalloonTableCellPositionData } from './utils/ui/contextualballoon.js';
+export { getBorderStyleLabels as _getBorderTableStyleLabels, getLocalizedColorErrorText as _getLocalizedTableColorErrorText, getLocalizedLengthErrorText as _getLocalizedTableLengthErrorText, colorFieldValidator as _colorTableFieldValidator, lengthFieldValidator as _lengthTableFieldValidator, lineWidthFieldValidator as _lineWidthTableFieldValidator, getBorderStyleDefinitions as _getTableOrCellBorderStyleDefinitions, fillToolbar as _fillTableOrCellToolbar, defaultColors as _TABLE_DEFAULT_COLORS, getLabeledColorInputCreator as _getLabeledTableColorInputCreator } from './utils/ui/table-properties.js';
+export { getSelectionAffectedTableWidget as _getSelectionAffectedTableWidget, getSelectedTableWidget as _getSelectedTableWidget, getTableWidgetAncestor as _getTableWidgetAncestor } from './utils/ui/widget.js';
+import './augmentation.js';

package/{dist → src}/plaintableoutput.d.ts

@@ -1,7 +1,3 @@
-/**
- * @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
- */
 /**
  * @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
@@ -9,7 +5,7 @@
 /**
  * @module table/plaintableoutput
  */
-import { Plugin } from '@ckeditor/ckeditor5-core';
+import { Plugin } from 'ckeditor5/src/core.js';
 import { Table } from './table.js';
 /**
  * The plain table output feature.

package/src/plaintableoutput.js

@@ -0,0 +1,49 @@
+/**
+ * @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/plaintableoutput
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import { Table } from './table.js';
+/**
+ * The plain table output feature.
+ *
+ * This feature strips the `<figure>` tag from the table data. This is because this tag is not supported
+ * by most popular email clients and removing it ensures compatibility.
+ */
+export class PlainTableOutput extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'PlainTableOutput';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [Table];
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        editor.conversion.for('upcast').add(dispatcher => {
+            dispatcher.on('element:table', (evt, data, conversionApi) => {
+                // It's not necessary to upcast the `table` class. This class was only added in data downcast
+                // to center a plain table in the editor output.
+                // See: https://github.com/ckeditor/ckeditor5/issues/17888.
+                conversionApi.consumable.consume(data.viewItem, { classes: 'table' });
+            });
+        });
+    }
+}

package/{dist → src}/table.d.ts

@@ -1,7 +1,3 @@
-/**
- * @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
- */
 /**
  * @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
@@ -9,8 +5,8 @@
 /**
  * @module table/table
  */
-import { Plugin } from '@ckeditor/ckeditor5-core';
-import { Widget } from '@ckeditor/ckeditor5-widget';
+import { Plugin } from 'ckeditor5/src/core.js';
+import { Widget } from 'ckeditor5/src/widget.js';
 import { TableEditing } from './tableediting.js';
 import { TableUI } from './tableui.js';
 import { TableSelection } from './tableselection.js';

package/src/table.js

@@ -0,0 +1,50 @@
+/**
+ * @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/table
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import { Widget } from 'ckeditor5/src/widget.js';
+import { TableEditing } from './tableediting.js';
+import { TableUI } from './tableui.js';
+import { TableSelection } from './tableselection.js';
+import { TableClipboard } from './tableclipboard.js';
+import { TableKeyboard } from './tablekeyboard.js';
+import { TableMouse } from './tablemouse.js';
+import '../theme/table.css';
+/**
+ * The table plugin.
+ *
+ * For a detailed overview, check the {@glink features/tables/tables Table feature documentation}.
+ *
+ * This is a "glue" plugin that loads the following table features:
+ *
+ * * {@link module:table/tableediting~TableEditing editing feature},
+ * * {@link module:table/tableselection~TableSelection selection feature},
+ * * {@link module:table/tablekeyboard~TableKeyboard keyboard navigation feature},
+ * * {@link module:table/tablemouse~TableMouse mouse selection feature},
+ * * {@link module:table/tableclipboard~TableClipboard clipboard feature},
+ * * {@link module:table/tableui~TableUI UI feature}.
+ */
+export class Table extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [TableEditing, TableUI, TableSelection, TableMouse, TableKeyboard, TableClipboard, Widget];
+    }
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'Table';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+}