@ui5/webcomponents 0.0.0-fca1107e7 → 0.0.0-fd426fe8a

package/dist/Table.js

@@ -6,861 +6,524 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var Table_1;
 import UI5Element from "@ui5/webcomponents-base/dist/UI5Element.js";
-import customElement from "@ui5/webcomponents-base/dist/decorators/customElement.js";
-import property from "@ui5/webcomponents-base/dist/decorators/property.js";
-import event from "@ui5/webcomponents-base/dist/decorators/event.js";
-import slot from "@ui5/webcomponents-base/dist/decorators/slot.js";
-import litRender from "@ui5/webcomponents-base/dist/renderer/LitRenderer.js";
+import { customElement, slot, property, eventStrict, i18n, } from "@ui5/webcomponents-base/dist/decorators.js";
+import query from "@ui5/webcomponents-base/dist/decorators/query.js";
+import jsxRenderer from "@ui5/webcomponents-base/dist/renderer/JsxRenderer.js";
+import TableTemplate from "./TableTemplate.js";
+import TableStyles from "./generated/themes/Table.css.js";
+import TableExtension from "./TableExtension.js";
+import TableNavigation from "./TableNavigation.js";
+import TableOverflowMode from "./types/TableOverflowMode.js";
+import TableDragAndDrop from "./TableDragAndDrop.js";
 import ResizeHandler from "@ui5/webcomponents-base/dist/delegate/ResizeHandler.js";
-import ItemNavigation from "@ui5/webcomponents-base/dist/delegate/ItemNavigation.js";
-import Integer from "@ui5/webcomponents-base/dist/types/Integer.js";
-import NavigationMode from "@ui5/webcomponents-base/dist/types/NavigationMode.js";
-import { isTabNext, isTabPrevious, isSpace, isEnter, isCtrlA, isUpAlt, isDownAlt, isUpShift, isDownShift, isHomeCtrl, isEndCtrl, isHomeShift, isEndShift, } from "@ui5/webcomponents-base/dist/Keys.js";
-import getNormalizedTarget from "@ui5/webcomponents-base/dist/util/getNormalizedTarget.js";
-import getActiveElement from "@ui5/webcomponents-base/dist/util/getActiveElement.js";
-import { getLastTabbableElement, getTabbableElements } from "@ui5/webcomponents-base/dist/util/TabbableElements.js";
-import { getEffectiveAriaLabelText } from "@ui5/webcomponents-base/dist/util/AriaLabelHelper.js";
-import { getI18nBundle } from "@ui5/webcomponents-base/dist/i18nBundle.js";
-import debounce from "@ui5/webcomponents-base/dist/util/debounce.js";
-import isElementInView from "@ui5/webcomponents-base/dist/util/isElementInView.js";
-import TableGrowingMode from "./types/TableGrowingMode.js";
-import BusyIndicator from "./BusyIndicator.js";
-import TableMode from "./types/TableMode.js";
-import CheckBox from "./CheckBox.js"; // Ensure the dependency as it is being used in the renderer
-// Texts
-import { LOAD_MORE_TEXT, ARIA_LABEL_SELECT_ALL_CHECKBOX, TABLE_HEADER_ROW_INFORMATION, TABLE_ROW_POSITION, } from "./generated/i18n/i18n-defaults.js";
-// Template
-import TableTemplate from "./generated/templates/TableTemplate.lit.js";
-// Styles
-import tableStyles from "./generated/themes/Table.css.js";
-const GROWING_WITH_SCROLL_DEBOUNCE_RATE = 250; // ms
-const PAGE_UP_DOWN_SIZE = 20;
-var TableFocusTargetElement;
-(function (TableFocusTargetElement) {
-    TableFocusTargetElement["Row"] = "tableRow";
-    TableFocusTargetElement["GroupRow"] = "tableGroupRow";
-    TableFocusTargetElement["ColumnHeader"] = "columnHeader";
-    TableFocusTargetElement["MoreButton"] = "moreButton";
-})(TableFocusTargetElement || (TableFocusTargetElement = {}));
+import { findVerticalScrollContainer, scrollElementIntoView, isFeature, isValidColumnWidth, } from "./TableUtils.js";
+import { getScopedVarName } from "@ui5/webcomponents-base/dist/CustomElementsScope.js";
+import { getEffectiveAriaLabelText } from "@ui5/webcomponents-base/dist/util/AccessibilityTextsHelper.js";
+import { TABLE_NO_DATA, } from "./generated/i18n/i18n-defaults.js";
 /**
  * @class
  *
  * ### Overview
  *
- * The `ui5-table` component provides a set of sophisticated and convenient functions for responsive table design.
- * It provides a comprehensive set of features for displaying and dealing with vast amounts of data.
+ * The `ui5-table` component provides a set of sophisticated features for displaying and dealing with vast amounts of data in a responsive manner.
+ * To render the `ui5-table`, you need to define the columns and rows. You can use the provided `ui5-table-header-row` and `ui5-table-row` components for this purpose.
  *
- * To render the `Table` properly, the order of the `columns` should match with the
- * order of the item `cells` in the `rows`.
+ * ### Features
  *
- * Desktop and tablet devices are supported.
- * On tablets, special consideration should be given to the number of visible columns
- * and rows due to the limited performance of some devices.
+ * The `ui5-table` can be enhanced in its functionalities by applying different features.
+ * Features can be slotted into the `features` slot, to enable them in the component.
+ * Features need to be imported separately, as they are not enabled by default.
  *
- * ### Selection
- * To benefit from the selection mechanism of `ui5-table` component, you can use the available selection modes:
- * `SingleSelect` and `MultiSelect`.
+ * The following features are currently available:
  *
- * In additition to the used mode, you can also specify the `ui5-table-row` type choosing between
- * `Active` or `Inactive`.
- *
- * In `SingleSelect` mode, you can select both an `Active` and `Inactive` row via mouse or
- * by pressing the `Space` or `Enter` keys.
- *
- * In `MultiSelect` mode, you can select both an `Active` and `Inactive` row by pressing the
- * `Space` key when a row is on focus or via mouse click over the selection checkbox of the row.
- * In order to select all the available rows at once, you can use the selection checkbox presented in the table's header.
- *
- * **Note:** Currently, when a column is shown as a pop-in, the visual indication for selection is not presented over it.
+ * * [TableSelection](../TableSelection) - adds selection capabilities to the table
+ * * [TableGrowing](../TableGrowing) - provides growing capabilities to load more data
  *
  * ### Keyboard Handling
  *
- * #### Fast Navigation
  * This component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].
  * In order to use this functionality, you need to import the following module:
  * `import "@ui5/webcomponents-base/dist/features/F6Navigation.js"`
  *
- * Furthermore, you can interact with `ui5-table` via the following keys.
+ * Furthermore, you can interact with `ui5-table` via the following keys:
+ *
+ * If the focus is on a row, the following keyboard shortcuts are available:
+ * * <kbd>Down</kbd> - Navigates down
+ * * <kbd>Up</kbd> - Navigates up
+ * * <kbd>Right</kbd> - Selects the first cell of the row
+ * * <kbd>Space</kbd> - Toggles the selection of the row
+ * * <kbd>Ctrl/Cmd + A</kbd> - In multi selection mode, toggles the selection of all rows
+ * * <kbd>Home</kbd> - Navigates to the first row, if the focus is on the first row, navigates to the header row
+ * * <kbd>End</kbd> - Navigates to the last row, if the focus is on the last row, navigates to the growing button
+ * * <kbd>Page Up</kbd> - Navigates one page up, if the focus is on the first row, navigates to the header row
+ * * <kbd>Page Down</kbd> - Navigates one page down, if the focus is on the last row, navigates to the growing button
+ * * <kbd>F2</kbd> - Focuses the first tabbable element in the row
+ * * <kbd>F7</kbd> - If focus position is remembered, moves focus to the corresponding focus position row, otherwise to the first tabbable element within the row
+ * * <kbd>[Shift]Tab</kbd> - Move focus to the element in the tab chain outside the table
+
  *
- * - [F7] - If focus is on an interactive control inside an item, moves focus to the corresponding item.
- * - [Ctrl]+[A] - Selects all items, if MultiSelect mode is enabled.
- * - [Home]/[End] - Focuses the first/last item.
- * - [Page Up]/[Page Down] - Moves focus up/down by page size (20 items by default).
- * - [Alt]+[Down]/[Up] - Switches focus between header, last focused item, and More button (if applies) in either direction.
- * - [Shift]+[Down]/[Up] - Selects the next/previous item in a MultiSelect table, if the current item is selected (Range selection). Otherwise, deselects them (Range deselection).
- * - [Shift]+[Home]/[End] - Range selection to the first/last item of the List.
- * - [Ctrl]+[Home]/[End] - Same behavior as HOME & END.
+ * If the focus is on a cell, the following keyboard shortcuts are available:
+ * * <kbd>Down</kbd> - Navigates down
+ * * <kbd>Up</kbd> - Navigates up
+ * * <kbd>Right</kbd> - Navigates right
+ * * <kbd>Left</kbd> - Navigates left, if the focus is on the first cell of the row, the focus is moved to the row.
+ * * <kbd>Home</kbd> - Navigates to the first cell of the current row, if the focus is on the first cell, navigates to the corresponding row
+ * * <kbd>End</kbd> - Navigates to the last cell of the current row, if the focus is on the last cell, navigates to the corresponding row
+ * * <kbd>Page Up</kbd> - Navigates one page up while keeping the focus in same column
+ * * <kbd>Page Down</kbd> - Navigates one page down while keeping the focus in same column
+ * * <kbd>F2</kbd> - Toggles the focus between the first tabbable cell content and the cell
+ * * <kbd>Enter</kbd> - Focuses the first tabbable cell content
+ * * <kbd>F7</kbd> - If the focus is on an interactive element inside a row, moves focus to the corresponding row and remembers the focus position of the element within the row
+ * * <kbd>[Shift]Tab</kbd> - Move focus to the element in the tab chain outside the table
+
+ *
+ * If the focus is on an interactive cell content, the following keyboard shortcuts are available:
+ * * <kbd>Down</kbd> - Move the focus to the interactive element in the same column of the previous row, unless the focused element prevents the default
+ * * <kbd>Up</kbd> - Move the focus to the interactive element in the same column of the next row, unless the focused element prevents the default
+ * * <kbd>[Shift]Tab</kbd> - Move the focus to the element in the tab chain
  *
  * ### ES6 Module Import
  *
- * `import "@ui5/webcomponents/dist/Table.js";`
- * `import "@ui5/webcomponents/dist/TableColumn.js";` (`ui5-table-column`)
- * `import "@ui5/webcomponents/dist/TableRow.js";` (`ui5-table-row`)
- * `import "@ui5/webcomponents/dist/TableGroupRow.js";` (`ui5-table-group-row`)
- * `import "@ui5/webcomponents/dist/TableCell.js";` (`ui5-table-cell`)
+ * `import "@ui5/webcomponents/dist/Table.js";`\
+ * `import "@ui5/webcomponents/dist/TableRow.js";` (`ui5-table-row`)\
+ * `import "@ui5/webcomponents/dist/TableCell.js";` (`ui5-table-cell`)\
+ * `import "@ui5/webcomponents/dist/TableHeaderRow.js";` (`ui5-table-header-row`)\
+ * `import "@ui5/webcomponents/dist/TableHeaderCell.js";` (`ui5-table-header-cell`)
+ *
  * @constructor
  * @extends UI5Element
+ * @since 2.0.0
  * @public
  */
 let Table = Table_1 = class Table extends UI5Element {
-    static async onDefine() {
-        Table_1.i18nBundle = await getI18nBundle("@ui5/webcomponents");
-    }
     constructor() {
         super();
-        this.visibleColumns = []; // template loop should always have a defined array
-        // The ItemNavigation requires each item to 1) have a "forcedTabIndex" property and 2) be either a UI5Element, or have an id property (to find it in the component's shadow DOM by)
-        this._columnHeader = {
-            id: `${this._id}-columnHeader`,
-            forcedTabIndex: "0",
-        };
-        this._itemNavigation = new ItemNavigation(this, {
-            navigationMode: NavigationMode.Vertical,
-            affectedPropertiesNames: ["_columnHeader"],
-            getItemsCallback: () => [this._columnHeader, ...this.rows],
-            skipItemsSize: PAGE_UP_DOWN_SIZE,
-        });
-        this._handleResize = this.popinContent.bind(this);
-        this.fnOnRowFocused = this.onRowFocused.bind(this);
-        this.fnHandleF7 = this._handleF7.bind(this);
-        this.tableEndObserved = false;
-        // Stores the last focused element within the table.
-        this.lastFocusedElement = null;
-        // Indicates whether the table is forwarding focus before or after the current table row.
-        this._forwardingFocus = false;
-        // Stores the last focused nested element index (within a table row) for F7 navigation.
-        this._prevNestedElementIndex = 0;
-        // Indicates the Table bottom most part has been detected by the IntersectionObserver
-        // for the first time.
-        this.initialIntersection = true;
+        /**
+         * Defines the mode of the <code>ui5-table</code> overflow behavior.
+         *
+         * Available options are:
+         *
+         * <code>Scroll</code> - Columns are shown as regular columns and horizontal scrolling is enabled.
+         * <code>Popin</code> - Columns are shown as pop-ins instead of regular columns.
+         *
+         * @default "Scroll"
+         * @public
+         */
+        this.overflowMode = "Scroll";
+        /**
+         * Defines if the loading indicator should be shown.
+         *
+         * **Note:** When the component is loading, it is not interactive.
+         *
+         * @default false
+         * @public
+         */
+        this.loading = false;
+        /**
+         * Defines the delay in milliseconds, after which the loading indicator will show up for this component.
+         *
+         * @default 1000
+         * @public
+         */
+        this.loadingDelay = 1000;
+        /**
+         * Defines the maximum number of row actions that is displayed, which determines the width of the row action column.
+         *
+         * **Note:** It is recommended to use a maximum of 3 row actions, as exceeding this limit may take up too much space on smaller screens.
+         *
+         * @default 0
+         * @since 2.7.0
+         * @public
+         */
+        this.rowActionCount = 0;
+        /**
+         * Defines the sticky top offset of the table, if other sticky elements outside of the table exist.
+         */
+        this.stickyTop = "0";
+        this._invalidate = 0;
+        this._renderNavigated = false;
+        this._events = ["keydown", "keyup", "click", "focusin", "focusout", "dragenter", "dragleave", "dragover", "drop"];
+        this._poppedIn = [];
+        this._containerWidth = 0;
+        this._onResizeBound = this._onResize.bind(this);
+        this._onEventBound = this._onEvent.bind(this);
+    }
+    onEnterDOM() {
+        this._events.forEach(eventType => this.addEventListener(eventType, this._onEventBound));
+        this.features.forEach(feature => feature.onTableActivate?.(this));
+        this._tableNavigation = new TableNavigation(this);
+        this._tableDragAndDrop = new TableDragAndDrop(this);
+    }
+    onExitDOM() {
+        this._tableNavigation = undefined;
+        this._tableDragAndDrop = undefined;
+        this._events.forEach(eventType => this.removeEventListener(eventType, this._onEventBound));
     }
     onBeforeRendering() {
-        const columnSettings = this.getColumnPropagationSettings();
-        const columnSettingsString = JSON.stringify(columnSettings);
-        const rowsCount = this.rows.length + 1;
-        const selectedRows = this.selectedRows;
-        this.rows.forEach((row, index) => {
-            if (row._columnsInfoString !== columnSettingsString) {
-                row._columnsInfo = columnSettings;
-                row._columnsInfoString = JSON.stringify(row._columnsInfo);
-            }
-            row.forcedAriaPosition = Table_1.i18nBundle.getText(TABLE_ROW_POSITION, index + 2, rowsCount);
-            row.forcedBusy = this.busy;
-            row.removeEventListener("ui5-_focused", this.fnOnRowFocused);
-            row.addEventListener("ui5-_focused", this.fnOnRowFocused);
-            row.removeEventListener("ui5-f7-pressed", this.fnHandleF7);
-            row.addEventListener("ui5-f7-pressed", this.fnHandleF7);
-            row.mode = this.mode;
+        this._renderNavigated = this.rows.some(row => row.navigated);
+        [...this.headerRow, ...this.rows].forEach(row => {
+            row._renderNavigated = this._renderNavigated;
+            row._rowActionCount = this.rowActionCount;
         });
-        this.visibleColumns = this.columns.filter((column, index) => {
-            return !this._hiddenColumns[index];
-        });
-        this._noDataDisplayed = !this.rows.length && !this.hideNoData;
-        this.visibleColumnsCount = this.visibleColumns.length;
-        if (this.isMultiSelect) {
-            // we have to count the selection column as well
-            this.visibleColumnsCount += 1;
+        this.style.setProperty(getScopedVarName("--ui5_grid_sticky_top"), this.stickyTop);
+        this._refreshPopinState();
+        this.features.forEach(feature => feature.onTableBeforeRendering?.(this));
+        if (this.getDomRef()) {
+            ResizeHandler.deregister(this, this._onResizeBound);
         }
-        this._allRowsSelected = selectedRows.length === this.rows.length;
-        this._prevFocusedRow = this._prevFocusedRow || this.rows[0];
     }
     onAfterRendering() {
-        if (this.growsOnScroll) {
-            this.observeTableEnd();
+        this.features.forEach(feature => feature.onTableAfterRendering?.(this));
+        if (this.overflowMode === TableOverflowMode.Popin) {
+            ResizeHandler.register(this, this._onResizeBound);
         }
-        this.checkTableInViewport();
     }
-    onEnterDOM() {
-        this.growingIntersectionObserver = this.getIntersectionObserver();
-        ResizeHandler.register(this.getDomRef(), this._handleResize);
-        this._itemNavigation.setCurrentItem(this.rows.length ? this.rows[0] : this._columnHeader);
+    _findFeature(featureName) {
+        return this.features.find(feature => isFeature(feature, featureName));
     }
-    onExitDOM() {
-        ResizeHandler.deregister(this.getDomRef(), this._handleResize);
-        this.growingIntersectionObserver.disconnect();
-        this.growingIntersectionObserver = null;
-        this.tableEndObserved = false;
+    _getSelection() {
+        return this._findFeature("TableSelectionBase") || this._findFeature("TableSelection");
     }
-    _onkeydown(e) {
-        if (isTabNext(e) || isTabPrevious(e)) {
-            this._handleTab(e);
-        }
-        if (isCtrlA(e)) {
-            e.preventDefault();
-            this.isMultiSelect && this._selectAll();
-        }
-        if (isUpAlt(e) || isDownAlt(e)) {
-            this._handleArrowAlt(e);
-        }
-        if ((isUpShift(e) || isDownShift(e)) && this.isMultiSelect) {
-            this._handleArrowNav(e);
-        }
-        if (isHomeCtrl(e)) {
-            e.preventDefault();
-            this._itemNavigation._handleHome();
-            this._itemNavigation._applyTabIndex();
-            this._itemNavigation._focusCurrentItem();
-        }
-        if (isEndCtrl(e)) {
-            e.preventDefault();
-            this._itemNavigation._handleEnd();
-            this._itemNavigation._applyTabIndex();
-            this._itemNavigation._focusCurrentItem();
-        }
-        if ((isHomeShift(e) || isEndShift(e)) && this.isMultiSelect) {
-            this._handleHomeEndSelection(e);
-        }
+    _getVirtualizer() {
+        return this._findFeature("TableVirtualizer");
     }
-    _handleTab(e) {
-        const isNext = isTabNext(e);
-        const target = getNormalizedTarget(e.target);
-        const targetType = this.getFocusedElementType(e.target);
-        if (this.columnHeaderTabbables.includes(target)) {
-            if (isNext && this.columnHeaderLastElement === target) {
-                return this._focusNextElement();
-            }
-            return;
-        }
-        if (isNext && targetType === TableFocusTargetElement.ColumnHeader && !this.columnHeaderTabbables.length) {
-            return this._focusNextElement();
-        }
-        if (targetType === TableFocusTargetElement.Row || !targetType) {
-            return;
-        }
-        switch (targetType) {
-            case TableFocusTargetElement.GroupRow:
-                return isNext ? this._focusNextElement() : this._focusForwardElement(false);
-            case TableFocusTargetElement.ColumnHeader:
-                return !isNext && this._focusForwardElement(false);
-            case TableFocusTargetElement.MoreButton:
-                if (isNext) {
-                    this._focusForwardElement(true);
-                }
-                else {
-                    e.preventDefault();
-                    this.currentElement?.focus();
+    _getGrowing() {
+        return this._findFeature("TableGrowing");
+    }
+    _onEvent(e) {
+        const composedPath = e.composedPath();
+        const eventOrigin = composedPath[0];
+        const elements = [this._tableNavigation, this._tableDragAndDrop, ...composedPath, ...this.features];
+        elements.forEach(element => {
+            if (element instanceof TableExtension || (element instanceof HTMLElement && element.localName.includes("ui5-table"))) {
+                const eventHandlerName = `_on${e.type}`;
+                const eventHandler = element[eventHandlerName];
+                if (typeof eventHandler === "function") {
+                    eventHandler.call(element, e, eventOrigin);
                 }
-        }
+            }
+        });
     }
-    _focusNextElement() {
-        if (!this.growsWithButton) {
-            this._focusForwardElement(true);
+    _onResize() {
+        const { clientWidth, scrollWidth } = this._tableElement;
+        if (scrollWidth > clientWidth) {
+            // Overflow Handling: Move columns into the popin until overflow is resolved
+            const overflow = scrollWidth - clientWidth;
+            const headers = this._getPopinOrderedColumns(false);
+            const poppedInWidth = headers.reduce((totalPoppedInWidth, headerCell) => {
+                if (totalPoppedInWidth < overflow && !headerCell._popin) {
+                    const headerWidth = Math.ceil(headerCell.getBoundingClientRect().width);
+                    totalPoppedInWidth += headerWidth;
+                    this._setHeaderPopinState(headerCell, true, headerWidth);
+                }
+                return totalPoppedInWidth;
+            }, 0);
+            // Calculate container width considering popped-in columns
+            const columnOverflow = poppedInWidth - overflow;
+            this._containerWidth = clientWidth - columnOverflow;
         }
         else {
-            this.morеBtn.focus();
-        }
-    }
-    _handleArrowNav(e) {
-        const isRowFocused = this.currentElement.localName === "tr";
-        if (!isRowFocused) {
-            return;
-        }
-        const previouslySelectedRows = this.selectedRows;
-        const currentItem = this.currentItem;
-        const currentItemIdx = this.currentItemIdx;
-        const prevItemIdx = currentItemIdx - 1;
-        const nextItemIdx = currentItemIdx + 1;
-        const prevItem = this.rows[prevItemIdx];
-        const nextItem = this.rows[nextItemIdx];
-        const wasSelected = !!currentItem.selected;
-        if ((isUpShift(e) && !prevItem) || (isDownShift(e) && !nextItem)) {
-            return;
-        }
-        if (isUpShift(e)) {
-            currentItem.selected = currentItem.selected && !prevItem.selected;
-            prevItem.selected = currentItem.selected || (wasSelected && !currentItem.selected);
-            prevItem.focus();
-        }
-        if (isDownShift(e)) {
-            currentItem.selected = currentItem.selected && !nextItem.selected;
-            nextItem.selected = currentItem.selected || (wasSelected && !currentItem.selected);
-            nextItem.focus();
+            // Underflow Handling: Restore columns from popin until container width is met
+            const headers = this._getPopinOrderedColumns(true).filter(it => it._popin);
+            headers.every(headerCell => {
+                const underflow = clientWidth - this._containerWidth;
+                if (underflow >= headerCell._popinWidth) {
+                    this._containerWidth += headerCell._popinWidth;
+                    this._setHeaderPopinState(headerCell, false, 0);
+                    return true;
+                }
+                return false;
+            });
         }
-        const selectedRows = this.selectedRows;
-        this.fireEvent("selection-change", {
-            selectedRows,
-            previouslySelectedRows,
-        });
     }
-    _handleHomeEndSelection(e) {
-        const isRowFocused = this.currentElement.localName === "tr";
-        if (!isRowFocused) {
+    _onfocusin(e) {
+        if (e.target === this) {
             return;
         }
-        const rows = this.rows;
-        const previouslySelectedRows = this.selectedRows;
-        const currentItemIdx = this.currentItemIdx;
-        if (isHomeShift(e)) {
-            rows.slice(0, currentItemIdx + 1).forEach(item => {
-                item.selected = true;
-            });
-            rows[0].focus();
-        }
-        if (isEndShift(e)) {
-            rows.slice(currentItemIdx).forEach(item => {
-                item.selected = true;
-            });
-            rows[rows.length - 1].focus();
-        }
-        const selectedRows = this.selectedRows;
-        this.fireEvent("selection-change", {
-            selectedRows,
-            previouslySelectedRows,
-        });
+        // Handles focus in the table, when the focus is below a sticky element
+        scrollElementIntoView(this._scrollContainer, e.target, this._stickyElements, this.effectiveDir === "rtl");
     }
-    /**
-     * Handles Alt + Up/Down.
-     * Switches focus between column header, last focused item, and "More" button (if applicable).
-     * @private
-     */
-    _handleArrowAlt(e) {
-        const shouldMoveUp = isUpAlt(e);
-        const target = e.target;
-        const focusedElementType = this.getFocusedElementType(target);
-        if (shouldMoveUp) {
-            switch (focusedElementType) {
-                case TableFocusTargetElement.Row:
-                case TableFocusTargetElement.GroupRow:
-                    this._prevFocusedRow = target;
-                    return this._onColumnHeaderClick(e);
-                case TableFocusTargetElement.ColumnHeader:
-                    return this.morеBtn ? this.morеBtn.focus() : this._prevFocusedRow?.focus();
-                case TableFocusTargetElement.MoreButton:
-                    return this._prevFocusedRow ? this._prevFocusedRow.focus() : this._onColumnHeaderClick(e);
-            }
-        }
-        else {
-            switch (focusedElementType) {
-                case TableFocusTargetElement.Row:
-                case TableFocusTargetElement.GroupRow:
-                    this._prevFocusedRow = target;
-                    return this.morеBtn ? this.morеBtn.focus() : this._onColumnHeaderClick(e);
-                case TableFocusTargetElement.ColumnHeader:
-                    if (this._prevFocusedRow) {
-                        this._prevFocusedRow.focus();
-                    }
-                    else if (this.morеBtn) {
-                        this.morеBtn.focus();
-                    }
-                    return;
-                case TableFocusTargetElement.MoreButton:
-                    return this._onColumnHeaderClick(e);
-            }
-        }
+    _onGrow() {
+        this._getGrowing()?.loadMore();
     }
-    /**
-     * Determines the type of the currently focused element.
-     * @private
-     */
-    getFocusedElementType(element) {
-        if (element === this.columnHeader) {
-            return TableFocusTargetElement.ColumnHeader;
-        }
-        if (element === this.morеBtn) {
-            return TableFocusTargetElement.MoreButton;
-        }
-        if (this.rows.includes(element)) {
-            const isGroupRow = element.hasAttribute("ui5-table-group-row");
-            return isGroupRow ? TableFocusTargetElement.GroupRow : TableFocusTargetElement.Row;
+    _getPopinOrderedColumns(reverse) {
+        let headers = [...this.headerRow[0].cells];
+        headers = headers.reverse(); // reverse the "visual" order
+        headers = headers.sort((a, b) => a.importance - b.importance); // sort by importance (asc)
+        headers.pop(); // remove the most important column, as it will not be popped in
+        if (reverse) {
+            headers = headers.reverse();
         }
+        return headers;
     }
     /**
-     * Toggles focus between the table row's root and the last focused nested element.
+     * Refreshes the popin state of the columns.
+     * Syncs the popin state of the columns with the popin state of the header cells.
+     * This is needed when additional rows are manually added and no resize happens.
      * @private
      */
-    _handleF7(e) {
-        const row = e.detail.row;
-        row.tabbableElements = getTabbableElements(row);
-        const activeElement = getActiveElement();
-        const lastFocusedElement = row.tabbableElements[this._prevNestedElementIndex] || row.tabbableElements[0];
-        const targetIndex = row.tabbableElements.indexOf(activeElement);
-        if (!row.tabbableElements.length) {
-            return;
-        }
-        if (activeElement === row.root) {
-            lastFocusedElement.focus();
-        }
-        else if (targetIndex > -1) {
-            this._prevNestedElementIndex = targetIndex;
-            row.root.focus();
-        }
-    }
-    _onfocusin(e) {
-        const target = getNormalizedTarget(e.target);
-        if (!this._isForwardElement(target)) {
-            this.lastFocusedElement = target;
-            return;
-        }
-        if (!this._forwardingFocus) {
-            if (this.lastFocusedElement) {
-                this.lastFocusedElement.focus();
-            }
-            else {
-                this.currentElement.focus();
-            }
-            e.stopImmediatePropagation();
-        }
-        this._forwardingFocus = false;
-    }
-    _onForwardBefore(e) {
-        this.lastFocusedElement = e.detail.target;
-        this._focusForwardElement(false);
-        e.stopImmediatePropagation();
-    }
-    _onForwardAfter(e) {
-        this.lastFocusedElement = e.detail.target;
-        if (!this.growsWithButton) {
-            this._focusForwardElement(true);
-        }
-        else {
-            this.morеBtn.focus();
-        }
-    }
-    _focusForwardElement(isAfter) {
-        this._forwardingFocus = true;
-        this.shadowRoot.querySelector(`#${this._id}-${isAfter ? "after" : "before"}`).focus();
-    }
-    _isForwardElement(element) {
-        const elementId = element.id;
-        const afterElement = this._getForwardElement(true);
-        const beforeElement = this._getForwardElement(false);
-        if (this._id === elementId || (beforeElement && beforeElement.id === elementId)) {
-            return true;
-        }
-        return !!(afterElement && afterElement.id === elementId);
-    }
-    _getForwardElement(isAfter) {
-        if (isAfter) {
-            return this._getAfterForwardElement();
-        }
-        return this._getBeforeForwardElement();
-    }
-    _getAfterForwardElement() {
-        if (!this._afterElement) {
-            this._afterElement = this.shadowRoot.querySelector(`[id="${this._id}-after"]`);
-        }
-        return this._afterElement;
-    }
-    _getBeforeForwardElement() {
-        if (!this._beforeElement) {
-            this._beforeElement = this.shadowRoot.querySelector(`[id="${this._id}-before"]`);
-        }
-        return this._beforeElement;
-    }
-    onRowFocused(e) {
-        this._itemNavigation.setCurrentItem(e.target);
-    }
-    _onColumnHeaderFocused() {
-        this._itemNavigation.setCurrentItem(this._columnHeader);
-    }
-    _onColumnHeaderClick(e) {
-        if (!e.target) {
-            this.columnHeader.focus();
-        }
-        const target = getNormalizedTarget(e.target);
-        const isNestedElement = this.columnHeaderTabbables.includes(target);
-        if (!isNestedElement) {
-            this.columnHeader.focus();
-        }
-    }
-    _onColumnHeaderKeydown(e) {
-        if (isSpace(e)) {
-            e.preventDefault();
-            this.isMultiSelect && this._selectAll();
-        }
-    }
-    _onLoadMoreKeydown(e) {
-        if (isSpace(e)) {
-            e.preventDefault();
-            this._loadMoreActive = true;
-        }
-        if (isEnter(e)) {
-            this._onLoadMoreClick();
-            this._loadMoreActive = true;
-        }
-    }
-    _onLoadMoreKeyup(e) {
-        if (isSpace(e)) {
-            this._onLoadMoreClick();
-        }
-        this._loadMoreActive = false;
-    }
-    _onLoadMoreClick() {
-        this.fireEvent("load-more");
-    }
-    observeTableEnd() {
-        if (!this.tableEndObserved) {
-            this.getIntersectionObserver().observe(this.tableEndDOM);
-            this.tableEndObserved = true;
-        }
-    }
-    onInteresection(entries) {
-        if (this.initialIntersection) {
-            this.initialIntersection = false;
-            return;
-        }
-        if (entries.some(entry => entry.isIntersecting)) {
-            debounce(this.loadMore.bind(this), GROWING_WITH_SCROLL_DEBOUNCE_RATE);
-        }
-    }
-    loadMore() {
-        this.fireEvent("load-more");
-    }
-    _handleSingleSelect(e) {
-        const row = this.getRowParent(e.target);
-        if (!row) {
-            return;
-        }
-        if (!row.selected) {
-            const previouslySelectedRows = this.selectedRows;
-            this.rows.forEach(item => {
-                if (item.selected) {
-                    item.selected = false;
-                }
-            });
-            row.selected = true;
-            this.fireEvent("selection-change", {
-                selectedRows: [row],
-                previouslySelectedRows,
-            });
-        }
-    }
-    _handleMultiSelect(e) {
-        const row = this.getRowParent(e.target);
-        const previouslySelectedRows = this.selectedRows;
-        if (!row) {
-            return;
-        }
-        row.selected = !row.selected;
-        const selectedRows = this.selectedRows;
-        if (selectedRows.length === this.rows.length) {
-            this._allRowsSelected = true;
-        }
-        else {
-            this._allRowsSelected = false;
-        }
-        this.fireEvent("selection-change", {
-            selectedRows,
-            previouslySelectedRows,
+    _refreshPopinState() {
+        this.headerRow[0]?.cells.forEach(header => {
+            this._setHeaderPopinState(header, header._popin, header._popinWidth);
         });
     }
-    _handleSelect(e) {
-        if (this.isSingleSelect) {
-            this._handleSingleSelect(e);
-            return;
-        }
-        if (this.isMultiSelect) {
-            this._handleMultiSelect(e);
-        }
-    }
-    _selectAll() {
-        const bAllSelected = !this._allRowsSelected;
-        const previouslySelectedRows = this.rows.filter(row => row.selected);
-        this._allRowsSelected = bAllSelected;
+    _setHeaderPopinState(headerCell, inPopin, popinWidth) {
+        const headerIndex = this.headerRow[0].cells.indexOf(headerCell);
+        headerCell._popin = inPopin && this.overflowMode === TableOverflowMode.Popin;
+        headerCell._popinWidth = popinWidth;
         this.rows.forEach(row => {
-            row.selected = bAllSelected;
-        });
-        const selectedRows = bAllSelected ? this.rows : [];
-        this.fireEvent("selection-change", {
-            selectedRows,
-            previouslySelectedRows,
-        });
-    }
-    getRowParent(child) {
-        if (child.hasAttribute("ui5-table-row")) {
-            return child;
-        }
-        const parent = child.parentElement;
-        if (!parent) {
-            return;
-        }
-        if (parent.hasAttribute("ui5-table-row")) {
-            return parent;
-        }
-        return this.getRowParent(parent);
-    }
-    get columnHeader() {
-        const domRef = this.getDomRef();
-        return domRef ? domRef.querySelector(`#${this._id}-columnHeader`) : null;
-    }
-    get morеBtn() {
-        const domRef = this.getDomRef();
-        if (this.growsWithButton && domRef) {
-            return domRef.querySelector(`#${this._id}-growingButton`);
-        }
-        return null;
-    }
-    handleResize() {
-        this.checkTableInViewport();
-        this.popinContent();
-    }
-    checkTableInViewport() {
-        this._inViewport = isElementInView(this.getDomRef());
-    }
-    popinContent() {
-        const clientRect = this.getDomRef().getBoundingClientRect();
-        const tableWidth = clientRect.width;
-        const hiddenColumns = [];
-        const visibleColumnsIndexes = [];
-        // store the hidden columns
-        this.columns.forEach((column, index) => {
-            if (tableWidth < column.minWidth && column.minWidth !== Infinity) {
-                hiddenColumns[index] = {
-                    index,
-                    popinText: column.popinText,
-                    demandPopin: column.demandPopin,
-                };
-            }
-            else {
-                visibleColumnsIndexes.push(index);
+            const cell = row.cells[headerIndex];
+            if (cell) {
+                row.cells[headerIndex]._popinHidden = headerCell.popinHidden;
+                row.cells[headerIndex]._popin = headerCell._popin;
             }
         });
-        if (visibleColumnsIndexes.length) {
-            if (!this.isMultiSelect) {
-                this.columns[visibleColumnsIndexes[0]].first = true;
-            }
-            this.columns[visibleColumnsIndexes[visibleColumnsIndexes.length - 1]].last = true;
-        }
-        const hiddenColumnsChange = (this._hiddenColumns.length !== hiddenColumns.length) || this._hiddenColumns.some((column, index) => column !== hiddenColumns[index]);
-        const shownColumnsChange = hiddenColumns.length === 0;
-        // invalidate if hidden columns count has changed or columns are shown
-        if (hiddenColumnsChange || shownColumnsChange) {
-            this._hiddenColumns = hiddenColumns;
-            this.fireEvent("popin-change", {
-                poppedColumns: this._hiddenColumns,
-            });
-        }
     }
-    /**
-     * Gets settings to be propagated from columns to rows.
-     */
-    getColumnPropagationSettings() {
-        return this.columns.map((column, index) => {
-            return {
-                index,
-                minWidth: column.minWidth,
-                demandPopin: column.demandPopin,
-                text: column.textContent,
-                popinText: column.popinText,
-                popinDisplay: column.popinDisplay,
-                visible: !this._hiddenColumns[index],
-            };
-        }, this);
+    _isGrowingFeature(feature) {
+        return Boolean(feature.loadMore && feature.hasGrowingComponent && isFeature(feature, "TableGrowing"));
     }
-    getIntersectionObserver() {
-        if (!this.growingIntersectionObserver) {
-            this.growingIntersectionObserver = new IntersectionObserver(this.onInteresection.bind(this), {
-                root: document,
-                rootMargin: "0px",
-                threshold: 1.0,
-            });
-        }
-        return this.growingIntersectionObserver;
+    _onRowClick(row) {
+        this.fireDecoratorEvent("row-click", { row });
+    }
+    _onRowActionClick(action) {
+        const row = action.parentElement;
+        this.fireDecoratorEvent("row-action-click", { action, row });
     }
     get styles() {
+        const virtualizer = this._getVirtualizer();
+        const headerStyleMap = this.headerRow?.[0]?.cells?.reduce((headerStyles, headerCell) => {
+            if (headerCell.horizontalAlign !== undefined && !headerCell._popin) {
+                headerStyles[`--horizontal-align-${headerCell._individualSlot}`] = headerCell.horizontalAlign;
+            }
+            return headerStyles;
+        }, {});
         return {
-            busy: {
-                position: this.busyIndPosition,
+            table: {
+                "grid-template-columns": this._gridTemplateColumns,
+                "--row-height": virtualizer ? `${virtualizer.rowHeight}px` : "auto",
+                ...headerStyleMap,
+            },
+            spacer: {
+                "transform": virtualizer?._getTransform(),
+                "will-change": virtualizer && "transform",
             },
         };
     }
-    get growsWithButton() {
-        return this.growing === TableGrowingMode.Button;
-    }
-    get growsOnScroll() {
-        return this.growing === TableGrowingMode.Scroll;
-    }
-    get _growingButtonText() {
-        return this.growingButtonText || Table_1.i18nBundle.getText(LOAD_MORE_TEXT);
-    }
-    get ariaLabelText() {
-        const rowsCount = this.rows.length + 1;
-        const headerRowText = Table_1.i18nBundle.getText(TABLE_HEADER_ROW_INFORMATION, rowsCount);
-        const columnsTitle = this.columns.map(column => {
-            return column.textContent.trim();
-        }).join(" ");
-        return `${headerRowText} ${columnsTitle}`;
-    }
-    get tableAriaLabelText() {
-        return getEffectiveAriaLabelText(this);
-    }
-    get ariaLabelSelectAllText() {
-        return Table_1.i18nBundle.getText(ARIA_LABEL_SELECT_ALL_CHECKBOX);
-    }
-    get loadMoreAriaLabelledBy() {
-        if (this.moreDataText) {
-            return `${this._id}-growingButton-text ${this._id}-growingButton-subtext`;
+    get _gridTemplateColumns() {
+        if (!this.headerRow[0]) {
+            return;
         }
-        return `${this._id}-growingButton-text`;
+        const widths = [];
+        const visibleHeaderCells = this.headerRow[0]._visibleCells;
+        // Selection Cell Width
+        if (this._isRowSelectorRequired) {
+            widths.push("min-content");
+        }
+        // Column Widths
+        widths.push(...visibleHeaderCells.map(cell => {
+            const minWidth = cell.minWidth ?? "3rem";
+            let width = `minmax(${minWidth}, 1fr)`; // default width
+            if (isValidColumnWidth(cell.width)) {
+                width = cell.width.includes("%") ? `max(${minWidth}, ${cell.width})` : cell.width;
+            }
+            return width;
+        }));
+        // Row Action Cell Width
+        if (this.rowActionCount > 0) {
+            widths.push(`calc(var(${getScopedVarName("--_ui5_button_base_min_width")}) * ${this.rowActionCount} + var(${getScopedVarName("--_ui5_table_row_actions_gap")}) * ${this.rowActionCount - 1} + var(${getScopedVarName("--_ui5_table_cell_horizontal_padding")}) * 2)`);
+        }
+        // Navigated Cell Width
+        if (this._renderNavigated) {
+            widths.push(`var(${getScopedVarName("--_ui5_table_navigated_cell_width")})`);
+        }
+        return widths.join(" ");
     }
-    get tableEndDOM() {
-        return this.shadowRoot.querySelector(".ui5-table-end-marker");
+    get _isRowSelectorRequired() {
+        return this.rows.length > 0 && this._getSelection()?.isRowSelectorRequired();
     }
-    get busyIndPosition() {
-        return this._inViewport ? "absolute" : "sticky";
+    get _scrollContainer() {
+        return this._getVirtualizer() ? this._tableElement : findVerticalScrollContainer(this);
     }
-    get isMultiSelect() {
-        return this.mode === TableMode.MultiSelect;
+    get _stickyElements() {
+        const stickyRows = this.headerRow.filter(row => row.sticky);
+        const stickyColumns = this.headerRow[0]._stickyCells;
+        return [...stickyRows, ...stickyColumns];
     }
-    get isSingleSelect() {
-        return this.mode === TableMode.SingleSelect;
+    get _effectiveNoDataText() {
+        return this.noDataText || Table_1.i18nBundle.getText(TABLE_NO_DATA);
     }
-    get selectedRows() {
-        return this.rows.filter(row => row.selected);
+    get _ariaLabel() {
+        return getEffectiveAriaLabelText(this) || undefined;
     }
-    get currentItemIdx() {
-        return this.rows.indexOf(this.currentItem);
+    get _ariaDescription() {
+        return this._getSelection()?.getAriaDescriptionForTable();
     }
-    get currentItem() {
-        return this.getRootNode().activeElement;
+    get _ariaRowCount() {
+        return this._getVirtualizer()?.rowCount || this.rows.length + 1;
     }
-    get currentElement() {
-        return this._itemNavigation._getCurrentItem();
+    get _ariaColCount() {
+        if (!this.headerRow[0]) {
+            return 0;
+        }
+        let ariaColCount = this.headerRow[0]._visibleCells.length;
+        if (this._isRowSelectorRequired) {
+            ariaColCount++;
+        }
+        if (this.rowActionCount > 0) {
+            ariaColCount++;
+        }
+        return ariaColCount;
     }
-    get columnHeaderTabbables() {
-        return this.columnHeader ? getTabbableElements(this.columnHeader) : [];
+    get _ariaMultiSelectable() {
+        const selection = this._getSelection();
+        return (selection?.isSelectable() && this.rows.length) ? selection.isMultiSelectable() : undefined;
     }
-    get columnHeaderLastElement() {
-        return this.columnHeader && getLastTabbableElement(this.columnHeader);
+    get isTable() {
+        return true;
     }
 };
 __decorate([
-    property()
-], Table.prototype, "noDataText", void 0);
+    slot({
+        type: HTMLElement,
+        "default": true,
+        invalidateOnChildChange: {
+            properties: ["navigated", "position"],
+            slots: false,
+        },
+    })
+], Table.prototype, "rows", void 0);
+__decorate([
+    slot({ type: HTMLElement, invalidateOnChildChange: { properties: false, slots: true } })
+], Table.prototype, "headerRow", void 0);
+__decorate([
+    slot()
+], Table.prototype, "noData", void 0);
+__decorate([
+    slot({ type: HTMLElement, individualSlots: true })
+], Table.prototype, "features", void 0);
 __decorate([
     property()
-], Table.prototype, "growingButtonText", void 0);
+], Table.prototype, "accessibleName", void 0);
 __decorate([
     property()
-], Table.prototype, "growingButtonSubtext", void 0);
+], Table.prototype, "accessibleNameRef", void 0);
 __decorate([
-    property({ type: Boolean })
-], Table.prototype, "hideNoData", void 0);
+    property()
+], Table.prototype, "noDataText", void 0);
 __decorate([
-    property({ type: TableGrowingMode, defaultValue: TableGrowingMode.None })
-], Table.prototype, "growing", void 0);
+    property()
+], Table.prototype, "overflowMode", void 0);
 __decorate([
     property({ type: Boolean })
-], Table.prototype, "busy", void 0);
+], Table.prototype, "loading", void 0);
 __decorate([
-    property({ validator: Integer, defaultValue: 1000 })
-], Table.prototype, "busyDelay", void 0);
+    property({ type: Number })
+], Table.prototype, "loadingDelay", void 0);
 __decorate([
-    property({ type: Boolean })
-], Table.prototype, "stickyColumnHeader", void 0);
+    property({ type: Number })
+], Table.prototype, "rowActionCount", void 0);
 __decorate([
-    property({ type: TableMode, defaultValue: TableMode.None })
-], Table.prototype, "mode", void 0);
+    property()
+], Table.prototype, "stickyTop", void 0);
 __decorate([
-    property({ defaultValue: undefined })
-], Table.prototype, "accessibleName", void 0);
+    property({ type: Number, noAttribute: true })
+], Table.prototype, "_invalidate", void 0);
 __decorate([
-    property({ defaultValue: "" })
-], Table.prototype, "accessibleNameRef", void 0);
+    property({ type: Boolean, noAttribute: true })
+], Table.prototype, "_renderNavigated", void 0);
 __decorate([
-    property({ type: Object, multiple: true })
-], Table.prototype, "_hiddenColumns", void 0);
+    query("[ui5-drop-indicator]")
+], Table.prototype, "dropIndicatorDOM", void 0);
 __decorate([
-    property({ type: Boolean })
-], Table.prototype, "_noDataDisplayed", void 0);
+    query("#no-data-row")
+], Table.prototype, "_noDataRow", void 0);
 __decorate([
-    property({ type: Boolean })
-], Table.prototype, "_loadMoreActive", void 0);
+    query("#table-end-row")
+], Table.prototype, "_endRow", void 0);
 __decorate([
-    property({ type: Object })
-], Table.prototype, "_columnHeader", void 0);
+    query("#table")
+], Table.prototype, "_tableElement", void 0);
 __decorate([
-    property({ type: Boolean })
-], Table.prototype, "_inViewport", void 0);
+    query("#before")
+], Table.prototype, "_beforeElement", void 0);
 __decorate([
-    property({ type: Boolean })
-], Table.prototype, "_allRowsSelected", void 0);
+    query("#after")
+], Table.prototype, "_afterElement", void 0);
 __decorate([
-    slot({
-        type: HTMLElement,
-        "default": true,
-        individualSlots: true,
-        invalidateOnChildChange: true,
-    })
-], Table.prototype, "rows", void 0);
+    query("#loading")
+], Table.prototype, "_loadingElement", void 0);
 __decorate([
-    slot({
-        type: HTMLElement,
-        individualSlots: true,
-        invalidateOnChildChange: {
-            properties: true,
-            slots: false,
-        },
-    })
-], Table.prototype, "columns", void 0);
+    i18n("@ui5/webcomponents")
+], Table, "i18nBundle", void 0);
 Table = Table_1 = __decorate([
     customElement({
         tag: "ui5-table",
-        fastNavigation: true,
-        styles: tableStyles,
-        renderer: litRender,
+        renderer: jsxRenderer,
+        styles: TableStyles,
         template: TableTemplate,
-        dependencies: [BusyIndicator, CheckBox],
+        fastNavigation: true,
     })
-    /** Fired when a row in `Active` mode is clicked or `Enter` key is pressed.
-     * @param {HTMLElement} row the activated row.
+    /**
+     * Fired when an interactive row is clicked.
+     *
+     * **Note:** This event is not fired if the `behavior` property of the selection component is set to `RowOnly`.
+     * In that case, use the `change` event of the selection component instead.
+     *
+     * @param {TableRow} row The row instance
      * @public
      */
     ,
-    event("row-click", {
-        detail: {
-            /**
-            * @public
-            */
-            row: { type: HTMLElement },
-        },
+    eventStrict("row-click", {
+        bubbles: false,
     })
     /**
-     * Fired when `ui5-table-column` is shown as a pop-in instead of hiding it.
-     * @param {Array} poppedColumns popped-in columns.
-     * @since 1.0.0-rc.6
+     * Fired when a movable item is moved over a potential drop target during a dragging operation.
+     *
+     * If the new position is valid, prevent the default action of the event using `preventDefault()`.
+     *
+     * **Note:** If the dragging operation is a cross-browser operation or files are moved to a potential drop target,
+     * the `source` parameter will be `null`.
+     *
+     * @param {Event} originalEvent The original `dragover` event
+     * @param {object} source The source object
+     * @param {object} destination The destination object
      * @public
      */
     ,
-    event("popin-change", {
-        detail: {
-            /**
-            * @public
-            */
-            poppedColumns: {
-                type: Array,
-            },
-        },
+    eventStrict("move-over", {
+        cancelable: true,
+        bubbles: true,
     })
     /**
-     * Fired when the user presses the `More` button or scrolls to the table's end.
+     * Fired when a movable list item is dropped onto a drop target.
      *
-     * **Note:** The event will be fired if `growing` is set to `Button` or `Scroll`.
+     * **Notes:**
+     *
+     * The `move` event is fired only if there was a preceding `move-over` with prevented default action.
+     *
+     * If the dragging operation is a cross-browser operation or files are moved to a potential drop target,
+     * the `source` parameter will be `null`.
+     *
+     * @param {Event} originalEvent The original `drop` event
+     * @param {object} source The source object
+     * @param {object} destination The destination object
      * @public
-     * @since 1.0.0-rc.11
      */
     ,
-    event("load-more")
+    eventStrict("move", {
+        bubbles: true,
+    })
     /**
-     * Fired when selection is changed by user interaction
-     * in `SingleSelect` and `MultiSelect` modes.
-     * @param {Array} selectedRows An array of the selected rows.
-     * @param {Array} previouslySelectedRows An array of the previously selected rows.
+     * Fired when a row action is clicked.
+     *
+     * @param {TableRowActionBase} action The row action instance
+     * @param {TableRow} row The row instance
+     * @since 2.6.0
      * @public
-     * @since 1.0.0-rc.15
      */
     ,
-    event("selection-change", {
-        detail: {
-            /**
-             * @public
-             */
-            selectedRows: { type: Array },
-            /**
-             * @public
-             */
-            previouslySelectedRows: { type: Array },
-        },
+    eventStrict("row-action-click", {
+        bubbles: false,
     })
 ], Table);
 Table.define();