@ui5/webcomponents 0.0.0-a3eca7ade → 0.0.0-a8a75c830

package/dist/Table.js

@@ -1,1010 +1,555 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Table_1;
 import UI5Element from "@ui5/webcomponents-base/dist/UI5Element.js";
-import litRender from "@ui5/webcomponents-base/dist/renderer/LitRenderer.js";
+import { customElement, slotStrict as 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 TableCustomAnnouncement from "./TableCustomAnnouncement.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 { isIE } from "@ui5/webcomponents-base/dist/Device.js";
-import {
-	isSpace,
-	isEnter,
-	isCtrlA,
-	isUpAlt,
-	isDownAlt,
-	isUpShift,
-	isDownShift,
-	isHomeCtrl,
-	isEndCtrl,
-	isHomeShift,
-	isEndShift,
-} from "@ui5/webcomponents-base/dist/Keys.js";
-import { getTabbableElements } from "@ui5/webcomponents-base/dist/util/TabbableElements.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_TEXT,
-	TABLE_ROW_POSITION,
-} from "./generated/i18n/i18n-defaults.js";
-
-// Template
-import TableTemplate from "./generated/templates/TableTemplate.lit.js";
-
-// Styles
-import styles from "./generated/themes/Table.css.js";
-
-const GROWING_WITH_SCROLL_DEBOUNCE_RATE = 250; // ms
-
-/**
- * @public
- */
-const metadata = {
-	tag: "ui5-table",
-	managedSlots: true,
-	fastNavigation: true,
-	slots: /** @lends sap.ui.webcomponents.main.Table.prototype */ {
-
-		/**
-		 * Defines the component rows.
-		 * <br><br>
-		 * <b>Note:</b> Use <code>ui5-table-row</code> for the intended design.
-		 *
-		 * @type {sap.ui.webcomponents.main.ITableRow[]}
-		 * @slot rows
-		 * @public
-		 */
-		"default": {
-			propertyName: "rows",
-			type: HTMLElement,
-			individualSlots: true,
-			invalidateOnChildChange: true,
-		},
-
-		/**
-		 * Defines the configuration for the columns of the component.
-		 * <br><br>
-		 * <b>Note:</b> Use <code>ui5-table-column</code> for the intended design.
-		 *
-		 * @type {sap.ui.webcomponents.main.ITableColumn[]}
-		 * @slot
-		 * @public
-		 */
-		columns: {
-			type: HTMLElement,
-			individualSlots: true,
-			invalidateOnChildChange: {
-				properties: true,
-				slots: false,
-			},
-		},
-	},
-	properties: /** @lends sap.ui.webcomponents.main.Table.prototype */ {
-
-		/**
-		 * Defines the text that will be displayed when there is no data and <code>hideNoData</code> is not present.
-		 *
-		 * @type {string}
-		 * @defaultvalue ""
-		 * @public
-		 */
-		noDataText: {
-			type: String,
-		},
-
-		/**
-		 * Defines the text that will be displayed inside the growing button at the bottom of the table,
-		 * meant for loading more rows upon press.
-		 *
-		 * <br><br>
-		 * <b>Note:</b> If not specified a built-in text will be displayed.
-		 * <br>
-		 * <b>Note:</b> This property takes effect if <code>growing</code> is set to <code>Button</code>.
-		 *
-		 * @type {string}
-		 * @defaultvalue ""
-		 * @since 1.0.0-rc.15
-		 * @public
-		 */
-		growingButtonText: {
-			type: String,
-		},
-
-		/**
-		 * Defines the subtext that will be displayed under the <code>growingButtonText</code>.
-		 *
-		 * <br><br>
-		 * <b>Note:</b> This property takes effect if <code>growing</code> is set to <code>Button</code>.
-		 *
-		 * @type {string}
-		 * @defaultvalue ""
-		 * @since 1.0.0-rc.15
-		 * @public
-		 */
-		 growingButtonSubtext: {
-			type: String,
-		},
-
-		/**
-		 * Defines if the value of <code>noDataText</code> will be diplayed when there is no rows present in the table.
-		 *
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @public
-		 * @since 1.0.0-rc.15
-		 */
-		hideNoData: {
-			type: Boolean,
-		},
-
-		/**
-		 * Defines whether the table will have growing capability either by pressing a <code>More</code> button,
-		 * or via user scroll. In both cases <code>load-more</code> event is fired.
-		 * <br><br>
-		 *
-		 * Available options:
-		 * <br><br>
-		 * <code>Button</code> - Shows a <code>More</code> button at the bottom of the table, pressing of which triggers the <code>load-more</code> event.
-		 * <br>
-		 * <code>Scroll</code> - The <code>load-more</code> event is triggered when the user scrolls to the bottom of the table;
-		 * <br>
-		 * <code>None</code> (default) - The growing is off.
-		 * <br><br>
-		 *
-		 * <b>Restrictions:</b> <code>growing="Scroll"</code> is not supported for Internet Explorer,
-		 * and the component will fallback to <code>growing="Button"</code>.
-		 * @type {TableGrowingMode}
-		 * @defaultvalue "None"
-		 * @since 1.0.0-rc.12
-		 * @public
-		 */
-		growing: {
-			type: TableGrowingMode,
-			defaultValue: TableGrowingMode.None,
-		},
-
-		/**
-		 * Defines if the table is in busy state.
-		 * <b>
-		 *
-		 * In this state the component's opacity is reduced
-		 * and busy indicator is displayed at the bottom of the table.
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @since 1.0.0-rc.12
-		 * @public
-		*/
-		busy: {
-			type: Boolean,
-		},
-
-		/**
-		 * Defines the delay in milliseconds, after which the busy indicator will show up for this component.
-		 *
-		 * @type {Integer}
-		 * @defaultValue 1000
-		 * @public
-		 */
-		busyDelay: {
-			type: Integer,
-			defaultValue: 1000,
-		},
-
-		/**
-		 * Determines whether the column headers remain fixed at the top of the page during
-		 * vertical scrolling as long as the Web Component is in the viewport.
-		 * <br><br>
-		 * <b>Restrictions:</b>
-		 * <ul>
-		 * <li>Browsers that do not support this feature:
-		 * <ul>
-		 * <li>Internet Explorer</li>
-		 * <li>Microsoft Edge lower than version 41 (EdgeHTML 16)</li>
-		 * <li>Mozilla Firefox lower than version 59</li>
-		 * </ul>
-		 * </li>
-		 * <li>Scrolling behavior:
-		 * <ul>
-		 * <li>If the Web Component is placed in layout containers that have the <code>overflow: hidden</code>
-		 * or <code>overflow: auto</code> style definition, this can
-		 * prevent the sticky elements of the Web Component from becoming fixed at the top of the viewport.</li>
-		 * </ul>
-		 * </li>
-		 * </ul>
-		 *
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @public
-		 */
-		stickyColumnHeader: {
-			type: Boolean,
-		},
-
-		/**
-		 * Defines the mode of the component.
-		 * <br><br>
-		 * Available options are:
-		 * <ul>
-		 * <li><code>MultiSelect</code></li>
-		 * <li><code>SingleSelect</code></li>
-		 * <li><code>None</code></li>
-		 * <ul>
-		 * @type {TableMode}
-		 * @defaultvalue "None"
-		 * @since 1.0.0-rc.15
-		 * @public
-		 */
-		mode: {
-			type: TableMode,
-			defaultValue: TableMode.None,
-		},
-
-		_hiddenColumns: {
-			type: Object,
-			multiple: true,
-		},
-
-		_noDataDisplayed: {
-			type: Boolean,
-		},
-
-		/**
-		 * Defines the active state of the <code>More</code> button.
-		 * @private
-		 */
-		_loadMoreActive: {
-			type: Boolean,
-		},
-
-		/**
-		 * Used to represent the table column header for the purpose of the item navigation as it does not work with DOM objects directly
-		 * @private
-		 */
-		_columnHeader: {
-			type: Object,
-		},
-
-		/**
-		 * Defines if the entire table is in view port.
-		 * @private
-		 */
-		_inViewport: {
-			type: Boolean,
-		},
-
-		/**
-		 * Defines whether all rows are selected or not when table is in MultiSelect mode.
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @since 1.0.0-rc.15
-		 * @private
-		 */
-		_allRowsSelected: {
-			type: Boolean,
-		},
-	},
-	events: /** @lends sap.ui.webcomponents.main.Table.prototype */ {
-		/**
-		 * Fired when a row in <code>Active</code> mode is clicked or <code>Enter</code> key is pressed.
-		 *
-		 * @event sap.ui.webcomponents.main.Table#row-click
-		 * @param {HTMLElement} row the activated row.
-		 * @public
-		 */
-		"row-click": {
-			detail: {
-				row: { type: HTMLElement },
-			},
-		},
-
-		/**
-		 * Fired when <code>ui5-table-column</code> is shown as a pop-in instead of hiding it.
-		 *
-		 * @event sap.ui.webcomponents.main.Table#popin-change
-		 * @param {Array} poppedColumns popped-in columns.
-		 * @since 1.0.0-rc.6
-		 * @public
-		 */
-		"popin-change": {
-			detail: {
-				poppedColumns: {},
-			},
-		},
-
-		/**
-		 * Fired when the user presses the <code>More</code> button or scrolls to the table's end.
-		 * <br><br>
-		 *
-		 * <b>Note:</b> The event will be fired if <code>growing</code> is set to <code>Button</code> or <code>Scroll</code>.
-		 * @event sap.ui.webcomponents.main.Table#load-more
-		 * @public
-		 * @since 1.0.0-rc.11
-		 */
-		"load-more": {},
-
-		/**
-		 * Fired when selection is changed by user interaction
-		 * in <code>SingleSelect</code> and <code>MultiSelect</code> modes.
-		 *
-		 * @event sap.ui.webcomponents.main.Table#selection-change
-		 * @param {Array} selectedRows An array of the selected rows.
-		 * @param {Array} previouslySelectedRows An array of the previously selected rows.
-		 * @public
-		 * @since 1.0.0-rc.15
-		 */
-		"selection-change": {
-			detail: {
-				selectedRows: { type: Array },
-				previouslySelectedRows: { type: Array },
-			},
-		},
-	},
-};
-
+import { findVerticalScrollContainer, scrollElementIntoView, isFeature, isValidColumnWidth, } from "./TableUtils.js";
+import { getEffectiveAriaLabelText } from "@ui5/webcomponents-base/dist/util/AccessibilityTextsHelper.js";
+import { TABLE_NO_DATA, } from "./generated/i18n/i18n-defaults.js";
 /**
  * @class
  *
- * <h3 class="comment-api-title">Overview</h3>
+ * ### Overview
+ *
+ * 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.
+ *
+ * ### Features
  *
- * The <code>ui5-table</code> 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.
- * <br><br>
- * To render the <code>Table</code> properly, the order of the <code>columns</code> should match with the
- * order of the item <code>cells</code> in the <code>rows</code>.
- * <br><br>
- * 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.
  *
- * <h3>Selection</h3>
- * To benefit from the selection mechanism of <code>ui5-table</code> component, you can use the available selection modes:
- * <code>SingleSelect</code> and <code>MultiSelect</code>.
- * <br>
- * In additition to the used mode, you can also specify the <code>ui5-table-row</code> type choosing between
- * <code>Active</code> or <code>Inactive</code>.
- * <br><br>
- * In <code>SingleSelect</code> mode, you can select both an <code>Active</code> and <code>Inactive</code> row via mouse or
- * by pressing the <code>Space</code> or <code>Enter</code> keys.
- * <br>
- * In <code>MultiSelect</code> mode, you can select both an <code>Active</code> and <code>Inactive</code> row by pressing the
- * <code>Space</code> 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.
- * <br><br>
- * <b>Note:</b> Currently, when a column is shown as a pop-in, the visual indication for selection is not presented over it.
+ * The following features are currently available:
  *
- * <h3>Keyboard Handling</h3>
+ * * [TableSelectionMulti](../TableSelectionMulti) - adds multi-selection capabilities to the table
+ * * [TableSelectionSingle](../TableSelectionSingle) - adds single-selection capabilities to the table
+ * * [TableGrowing](../TableGrowing) - provides growing capabilities to load more data
+ * * [TableVirtualizer](../TableVirtualizer) - adds virtualization capabilities to the table
  *
- * <h4>Fast Navigation</h4>
- * This component provides a build in fast navigation group which can be used via <code>F6 / Shift + F6</code> or <code> Ctrl + Alt(Option) + Down /  Ctrl + Alt(Option) + Up</code>.
+ * ### Keyboard Handling
+ *
+ * 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:
- * <code>import "@ui5/webcomponents-base/dist/features/F6Navigation.js"</code>
- * <br><br>
- * Furthermore, you can interact with <code>ui5-table</code> via the following keys.
- * <br>
+ * `import "@ui5/webcomponents-base/dist/features/F6Navigation.js"`
+ *
+ * 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
+ *
+ * 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
  *
- * <ul>
- * <li>[F7] - If focus is on an interactive control inside an item, moves focus to the corresponding item.</li>
- * <li>[CTRL]+[A] - Selects all items, if MultiSelect mode is enabled.</li>
- * <li>[HOME]/[END] - Focuses the first/last item.</li>
- * <li>[PAGEUP]/[PAGEDOWN] - Moves focus up/down by page size (20 items by default).</li>
- * <li>[ALT]+[DOWN]/[UP] - Switches focus between header, last focused item, and More button (if applies) in either direction.</li>
- * <li>[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).</li>
- * <li>[SHIFT]+[HOME]/[END] - Range selection to the first/last item of the List.</li>
- * <li>[CTRL]+[HOME]/[END] - Same behavior as HOME & END.</li> * </ul>
+ * 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
  *
- * <h3>ES6 Module Import</h3>
+ * ### Accessibility
  *
- * <code>import "@ui5/webcomponents/dist/Table.js";</code>
- * <br>
- * <code>import "@ui5/webcomponents/dist/TableColumn.js";</code> (for <code>ui5-table-column</code>)
- * <br>
- * <code>import "@ui5/webcomponents/dist/TableRow.js";</code> (for <code>ui5-table-row</code>)
- * <br>
- * <code>import "@ui5/webcomponents/dist/TableCell.js";</code> (for <code>ui5-table-cell</code>)
+ * The `ui5-table` follows the [ARIA grid design pattern](https://www.w3.org/WAI/ARIA/apg/patterns/grid/).
+ * This pattern enables cell-based keyboard navigation and, as explained above, we also support row-based keyboard navigation.
+ * Since the grid design pattern does not inherently provide row-based keyboard behavior, if the focus is on a row, not only the row information but also the corresponding column headers for each cell must be announced.
+ * This can only be achieved through a custom accessibility announcement.
+ * To support this, UI5 Web Components expose its own accessibility metadata via the `accessibilityInfo` property.
+ * The `ui5-table` uses this information to create the required custom announcements dynamically.
+ * If you include custom web components inside table cells that are not part of the standard UI5 Web Components set, their accessibility information can be provided using the `data-ui5-acc-text` attribute.
+ *
+ * ### ES6 Module Import
+ *
+ * `import "@ui5/webcomponents/dist/Table.js";` (`ui5-table`)\
+ * `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
- * @author SAP SE
- * @alias sap.ui.webcomponents.main.Table
- * @extends sap.ui.webcomponents.base.UI5Element
- * @tagname ui5-table
- * @appenddocs TableColumn TableRow TableGroupRow TableCell
+ * @extends UI5Element
+ * @since 2.0.0
  * @public
  */
-class Table extends UI5Element {
-	static get metadata() {
-		return metadata;
-	}
-
-	static get styles() {
-		return styles;
-	}
-
-	static get render() {
-		return litRender;
-	}
-
-	static get template() {
-		return TableTemplate;
-	}
-
-	static get dependencies() {
-		return [BusyIndicator, CheckBox];
-	}
-
-	static async onDefine() {
-		Table.i18nBundle = await getI18nBundle("@ui5/webcomponents");
-	}
-
-	constructor() {
-		super();
-
-		// The ItemNavigation requires each item to 1) have a "_tabIndex" 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`,
-			_tabIndex: "0",
-		};
-
-		this._itemNavigation = new ItemNavigation(this, {
-			navigationMode: NavigationMode.Vertical,
-			affectedPropertiesNames: ["_columnHeader"],
-			getItemsCallback: () => [this._columnHeader, ...this.rows],
-			skipItemsSize: 20,
-		});
-
-		this.fnOnRowFocused = this.onRowFocused.bind(this);
-
-		this._handleResize = this.popinContent.bind(this);
-
-		this.tableEndObserved = false;
-
-		this.addEventListener("ui5-selection-requested", this._handleSelect.bind(this));
-
-		this._prevNestedElementIndex = 0;
-	}
-
-	onBeforeRendering() {
-		const columnSettings = this.getColumnPropagationSettings();
-		const columnSettingsString = JSON.stringify(columnSettings);
-		const rowsCount = this.rows.length;
-		const selectedRows = this.selectedRows;
-
-		this.rows.forEach((row, index) => {
-			if (row._columnsInfoString !== columnSettingsString) {
-				row._columnsInfo = columnSettings;
-				row._columnsInfoString = JSON.stringify(row._columnsInfo);
-			}
-
-			row._ariaPosition = Table.i18nBundle.getText(TABLE_ROW_POSITION, index + 1, rowsCount);
-			row._busy = this.busy;
-			row.removeEventListener("ui5-_focused", this.fnOnRowFocused);
-			row.addEventListener("ui5-_focused", this.fnOnRowFocused);
-			row.mode = this.mode;
-		});
-
-		this.visibleColumns = this.columns.filter((column, index) => {
-			return !this._hiddenColumns[index];
-		});
-
-		this._noDataDisplayed = !this.rows.length && !this.hideNoData;
-		this.visibleColumnsCount = this.visibleColumns.length;
-
-		this._allRowsSelected = selectedRows.length === this.rows.length;
-
-		this._previousFocusedRow = this._previousFocusedRow || this.rows[0] || null;
-	}
-
-	onAfterRendering() {
-		if (this.growsOnScroll) {
-			this.observeTableEnd();
-		}
-
-		this.checkTableInViewport();
-	}
-
-	onEnterDOM() {
-		if (!isIE()) {
-			this.growingIntersectionObserver = this.getIntersectionObserver();
-		}
-
-		ResizeHandler.register(this.getDomRef(), this._handleResize);
-
-		this._itemNavigation.setCurrentItem(this.rows.length ? this.rows[0] : this._columnHeader);
-
-		this.rows.forEach((row, index) => {
-			row._tabbableElements = getTabbableElements(row);
-
-			if (index > 0) {
-				row._tabbableElements.forEach(el => el.setAttribute("tabindex", "-1"));
-			}
-		});
-	}
-
-	onExitDOM() {
-		ResizeHandler.deregister(this.getDomRef(), this._handleResize);
-
-		if (!isIE()) {
-			this.growingIntersectionObserver.disconnect();
-			this.growingIntersectionObserver = null;
-			this.tableEndObserved = false;
-		}
-	}
-
-	_onkeydown(event) {
-		if (isCtrlA(event)) {
-			event.preventDefault();
-			this.isMultiSelect && this._selectAll(event);
-			return;
-		}
-
-		const isAltUp = isUpAlt(event);
-
-		if (isAltUp || isDownAlt(event)) {
-			return this._handleArrowAlt(isAltUp, event.target);
-		}
-
-		if ((isUpShift(event) || isDownShift(event)) && this.isMultiSelect) {
-			this._handleArrowNav(event);
-		}
-
-		if (isHomeCtrl(event)) {
-			event.preventDefault();
-
-			this._itemNavigation._handleHome(event);
-			this._itemNavigation._applyTabIndex();
-			this._itemNavigation._focusCurrentItem();
-		}
-
-		if (isEndCtrl(event)) {
-			event.preventDefault();
-
-			this._itemNavigation._handleEnd(event);
-			this._itemNavigation._applyTabIndex();
-			this._itemNavigation._focusCurrentItem();
-		}
-
-		if ((isHomeShift(event) || isEndShift(event)) && this.isMultiSelect) {
-			this._handleHomeEndSelection(event);
-		}
-	}
-
-	_handleArrowNav(event) {
-		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(event) && !prevItem) || (isDownShift(event) && !nextItem)) {
-			return;
-		}
-
-		if (isUpShift(event)) {
-			currentItem.selected = currentItem.selected && !prevItem.selected;
-			prevItem.selected = currentItem.selected || (wasSelected && !currentItem.selected);
-
-			prevItem.focus();
-		}
-
-		if (isDownShift(event)) {
-			currentItem.selected = currentItem.selected && !nextItem.selected;
-			nextItem.selected = currentItem.selected || (wasSelected && !currentItem.selected);
-
-			nextItem.focus();
-		}
-
-		const selectedRows = this.selectedRows;
-
-		this.fireEvent("selection-change", {
-			selectedRows,
-			previouslySelectedRows,
-		});
-	}
-
-	_handleHomeEndSelection(event) {
-		const isRowFocused = this.currentElement.localName === "tr";
-
-		if (!isRowFocused) {
-			return;
-		}
-		const rows = this.rows;
-		const previouslySelectedRows = this.selectedRows;
-		const currentItemIdx = this.currentItemIdx;
-
-		if (isHomeShift(event)) {
-			rows.slice(0, currentItemIdx + 1).forEach(item => {
-				item.selected = true;
-			});
-			rows[0].focus();
-		}
-
-		if (isEndShift(event)) {
-			rows.slice(currentItemIdx).forEach(item => {
-				item.selected = true;
-			});
-			rows[rows.length - 1].focus();
-		}
-
-		const selectedRows = this.selectedRows;
-
-		this.fireEvent("selection-change", {
-			selectedRows,
-			previouslySelectedRows,
-		});
-	}
-
-	/**
-	 * Handles Alt + Up/Down.
-	 * Switches focus between column header, last focused item, and "More" button (if applicable).
-	 * @private
-	 * @param {boolean} shouldMoveUp Whether to move focus upward
-	 * @param {object} focusedElement The element currently in focus
-	 */
-	_handleArrowAlt(shouldMoveUp, focusedElement) {
-		const focusedElementType = this.getFocusedElementType(focusedElement);
-		const moreButton = this.getMoreButton();
-
-		if (shouldMoveUp) {
-			switch (focusedElementType) {
-			case "tableRow":
-				this._previousFocusedRow = focusedElement;
-				return this._onColumnHeaderClick();
-			case "columnHeader":
-				return moreButton ? moreButton.focus() : this._previousFocusedRow.focus();
-			case "moreButton":
-				return this._previousFocusedRow ? this._previousFocusedRow.focus() : this._onColumnHeaderClick();
-			}
-		} else {
-			switch (focusedElementType) {
-			case "tableRow":
-				this._previousFocusedRow = focusedElement;
-				return moreButton ? moreButton.focus() : this._onColumnHeaderClick();
-			case "columnHeader":
-				if (this._previousFocusedRow) {
-					return this._previousFocusedRow.focus();
-				}
-
-				if (moreButton) {
-					return moreButton.focus();
-				}
-
-				return;
-			case "moreButton":
-				return this._onColumnHeaderClick();
-			}
-		}
-	}
-
-	/**
-	 * Determines the type of the currently focused element.
-	 * @private
-	 * @param {object} element The object representation of the DOM element
-	 * @returns {("columnHeader"|"tableRow"|"moreButton")} A string identifier
-	 */
-	getFocusedElementType(element) {
-		if (element === this.getColumnHeader()) {
-			return "columnHeader";
-		}
-
-		if (element === this.getMoreButton()) {
-			return "moreButton";
-		}
-
-		if (this.rows.includes(element)) {
-			return "tableRow";
-		}
-	}
-
-	onRowFocused(event) {
-		this._itemNavigation.setCurrentItem(event.target);
-	}
-
-	_onColumnHeaderClick(event) {
-		this.getColumnHeader().focus();
-		this._itemNavigation.setCurrentItem(this._columnHeader);
-	}
-
-	_onColumnHeaderKeydown(event) {
-		if (isSpace(event)) {
-			event.preventDefault();
-			this.isMultiSelect && this._selectAll();
-		}
-	}
-
-	_onLoadMoreKeydown(event) {
-		if (isSpace(event)) {
-			event.preventDefault();
-			this._loadMoreActive = true;
-		}
-
-		if (isEnter(event)) {
-			this._onLoadMoreClick();
-			this._loadMoreActive = true;
-		}
-	}
-
-	_onLoadMoreKeyup(event) {
-		if (isSpace(event)) {
-			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 (entries.some(entry => entry.isIntersecting)) {
-			debounce(this.loadMore.bind(this), GROWING_WITH_SCROLL_DEBOUNCE_RATE);
-		}
-	}
-
-	loadMore() {
-		this.fireEvent("load-more");
-	}
-
-	_handleSingleSelect(event) {
-		const row = this.getRowParent(event.target);
-		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(event) {
-		const row = this.getRowParent(event.target);
-		const previouslySelectedRows = this.selectedRows;
-
-		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,
-		});
-	}
-
-	_handleSelect(event) {
-		this[`_handle${this.mode}`](event);
-	}
-
-	_selectAll(event) {
-		const bAllSelected = !this._allRowsSelected;
-		const previouslySelectedRows = this.rows.filter(row => row.selected);
-
-		this._allRowsSelected = bAllSelected;
-
-		this.rows.forEach(row => {
-			row.selected = bAllSelected;
-		});
-
-		const selectedRows = bAllSelected ? this.rows : [];
-
-		this.fireEvent("selection-change", {
-			selectedRows,
-			previouslySelectedRows,
-		});
-	}
-
-	getRowParent(child) {
-		const parent = child.parentElement;
-
-		if (child.hasAttribute("ui5-table-row")) {
-			return child;
-		}
-
-		if (parent && parent.hasAttribute("ui5-table-row")) {
-			return parent;
-		}
-
-		this.getRowParent(parent);
-	}
-
-	getColumnHeader() {
-		return this.getDomRef() && this.getDomRef().querySelector(`#${this._id}-columnHeader`);
-	}
-
-	getMoreButton() {
-		return this.growsWithButton && this.getDomRef() && this.getDomRef().querySelector(`#${this._id}-growingButton`);
-	}
-
-	handleResize(event) {
-		this.checkTableInViewport();
-		this.popinContent(event);
-	}
-
-	checkTableInViewport() {
-		this._inViewport = isElementInView(this.getDomRef());
-	}
-
-	popinContent(_event) {
-		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);
-			}
-		});
-
-		if (visibleColumnsIndexes.length) {
-			if (!this.isMultiSelect) {
-				this.columns[visibleColumnsIndexes[0]].first = true;
-			}
-			this.columns[visibleColumnsIndexes[visibleColumnsIndexes.length - 1]].last = true;
-		}
-
-		// invalidate only if hidden columns count has changed
-		if (this._hiddenColumns.length !== hiddenColumns.length) {
-			this._hiddenColumns = hiddenColumns;
-			if (hiddenColumns.length) {
-				this.fireEvent("popin-change", {
-					poppedColumns: this._hiddenColumns,
-				});
-			}
-		}
-	}
-
-	/**
-	 * Gets settings to be propagated from columns to rows.
-	 *
-	 * @returns {object}
-	 * @memberof Table
-	 */
-	getColumnPropagationSettings() {
-		return this.columns.map((column, index) => {
-			return {
-				index,
-				minWidth: column.minWidth,
-				demandPopin: column.demandPopin,
-				text: column.textContent,
-				popinText: column.popinText,
-				visible: !this._hiddenColumns[index],
-			};
-		}, this);
-	}
-
-	getIntersectionObserver() {
-		if (!this.growingIntersectionObserver) {
-			this.growingIntersectionObserver = new IntersectionObserver(this.onInteresection.bind(this), {
-				root: document,
-				rootMargin: "0px",
-				threshold: 1.0,
-			});
-		}
-
-		return this.growingIntersectionObserver;
-	}
-
-	get styles() {
-		return {
-			busy: {
-				position: this.busyIndPosition,
-			},
-		};
-	}
-
-	get growsWithButton() {
-		if (isIE()) {
-			// On IE fallback to "More" button, even if growing of type "Scroll" is set.
-			return this.growing === TableGrowingMode.Button || this.growing === TableGrowingMode.Scroll;
-		}
-
-		return this.growing === TableGrowingMode.Button;
-	}
-
-	get growsOnScroll() {
-		return !isIE() && this.growing === TableGrowingMode.Scroll;
-	}
-
-	get _growingButtonText() {
-		return this.growingButtonText || Table.i18nBundle.getText(LOAD_MORE_TEXT);
-	}
-
-	get ariaLabelText() {
-		const headerRowText = Table.i18nBundle.getText(TABLE_HEADER_ROW_TEXT);
-		const columnsTitle = this.columns.map(column => {
-			return column.textContent.trim();
-		}).join(" ");
-
-		return `${headerRowText} ${columnsTitle}`;
-	}
-
-	get ariaLabelSelectAllText() {
-		return Table.i18nBundle.getText(ARIA_LABEL_SELECT_ALL_CHECKBOX);
-	}
-
-	get loadMoreAriaLabelledBy() {
-		if (this.moreDataText) {
-			return `${this._id}-growingButton-text ${this._id}-growingButton-subtext`;
-		}
-
-		return `${this._id}-growingButton-text`;
-	}
-
-	get tableEndDOM() {
-		return this.shadowRoot.querySelector(".ui5-table-end-marker");
-	}
-
-	get busyIndPosition() {
-		if (isIE()) {
-			return "absolute";
-		}
-
-		return this._inViewport ? "absolute" : "sticky";
-	}
-
-	get isMultiSelect() {
-		return this.mode === "MultiSelect";
-	}
-
-	get selectedRows() {
-		return this.rows.filter(row => row.selected);
-	}
-
-	get currentItemIdx() {
-		return this.rows.indexOf(this.currentItem);
-	}
-
-	get currentItem() {
-		return this.getRootNode().activeElement;
-	}
-
-	get currentElement() {
-		return this._itemNavigation._getCurrentItem();
-	}
-}
-
+let Table = Table_1 = class Table extends UI5Element {
+    constructor() {
+        super();
+        /**
+         * 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;
+        /**
+         * Determines whether the table rows are displayed with alternating background colors.
+         *
+         * @default false
+         * @since 2.17
+         * @public
+         */
+        this.alternateRowColors = false;
+        /**
+         * 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", "dragstart", "dragenter", "dragleave", "dragover", "drop", "dragend"];
+        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);
+        this._tableCustomAnnouncement = new TableCustomAnnouncement(this);
+    }
+    onExitDOM() {
+        this._tableNavigation = undefined;
+        this._tableDragAndDrop = undefined;
+        this._events.forEach(eventType => this.removeEventListener(eventType, this._onEventBound));
+    }
+    onBeforeRendering() {
+        this._renderNavigated = this.rows.some(row => row.navigated);
+        [...this.headerRow, ...this.rows].forEach((row, index) => {
+            row._renderNavigated = this._renderNavigated;
+            row._rowActionCount = this.rowActionCount;
+            row._alternate = this.alternateRowColors && index % 2 === 0;
+        });
+        this.style.setProperty("--ui5_grid_sticky_top", this.stickyTop);
+        this._refreshPopinState();
+        this.features.forEach(feature => feature.onTableBeforeRendering?.(this));
+        if (this.getDomRef()) {
+            ResizeHandler.deregister(this, this._onResizeBound);
+        }
+    }
+    onAfterRendering() {
+        this.features.forEach(feature => feature.onTableAfterRendering?.(this));
+        if (this.overflowMode === TableOverflowMode.Popin) {
+            ResizeHandler.register(this, this._onResizeBound);
+        }
+    }
+    _findFeature(featureName) {
+        return this.features.find(feature => isFeature(feature, featureName));
+    }
+    _getSelection() {
+        return this._findFeature("TableSelectionBase") || this._findFeature("TableSelection");
+    }
+    _getVirtualizer() {
+        return this._findFeature("TableVirtualizer");
+    }
+    _getGrowing() {
+        return this._findFeature("TableGrowing");
+    }
+    _onEvent(e) {
+        const composedPath = e.composedPath();
+        const eventOrigin = composedPath[0];
+        const elements = [this._tableCustomAnnouncement, this._tableNavigation, this._tableDragAndDrop, ...composedPath, ...this.features].filter(Boolean);
+        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);
+                }
+            }
+        });
+    }
+    _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 {
+            // 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;
+            });
+        }
+    }
+    _onfocusin(e) {
+        if (e.target === this) {
+            return;
+        }
+        // Handles focus in the table, when the focus is below a sticky element
+        scrollElementIntoView(this._scrollContainer, e.target, this._stickyElements, this.effectiveDir === "rtl");
+    }
+    _onGrow() {
+        this._getGrowing()?.loadMore();
+    }
+    _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;
+    }
+    /**
+     * 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
+     */
+    _refreshPopinState() {
+        this.headerRow[0]?.cells.forEach(header => {
+            this._setHeaderPopinState(header, header._popin, header._popinWidth);
+        });
+    }
+    _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 => {
+            const cell = row.cells[headerIndex];
+            if (cell) {
+                row.cells[headerIndex]._popinHidden = headerCell.popinHidden;
+                row.cells[headerIndex]._popin = headerCell._popin;
+            }
+        });
+    }
+    _isGrowingFeature(feature) {
+        return Boolean(feature.loadMore && feature.hasGrowingComponent && isFeature(feature, "TableGrowing"));
+    }
+    _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.forEach(headerCell => {
+            headerStyleMap[`--halign-${headerCell._id}`] = headerCell.horizontalAlign || "normal";
+        });
+        return {
+            table: {
+                "grid-template-columns": this._gridTemplateColumns,
+                "--row-height": virtualizer ? `${virtualizer.rowHeight}px` : "auto",
+                ...headerStyleMap,
+            },
+            spacer: {
+                "transform": virtualizer?._getTransform(),
+                "will-change": virtualizer && "transform",
+            },
+        };
+    }
+    get _gridTemplateColumns() {
+        if (!this.headerRow[0]) {
+            return;
+        }
+        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(--_ui5_button_base_min_width) * ${this.rowActionCount} + var(--_ui5_table_row_actions_gap) * ${this.rowActionCount - 1} + var(--_ui5_table_cell_horizontal_padding) * 2)`);
+        }
+        // Navigated Cell Width
+        if (this._renderNavigated) {
+            widths.push(`var(--_ui5_table_navigated_cell_width)`);
+        }
+        return widths.join(" ");
+    }
+    get _isRowSelectorRequired() {
+        return this.rows.length > 0 && this._getSelection()?.isRowSelectorRequired();
+    }
+    get _scrollContainer() {
+        return this._getVirtualizer() ? this._tableElement : findVerticalScrollContainer(this);
+    }
+    get _stickyElements() {
+        const stickyRows = this.headerRow.filter(row => row.sticky);
+        const stickyColumns = this.headerRow[0]._stickyCells;
+        return [...stickyRows, ...stickyColumns];
+    }
+    get _effectiveNoDataText() {
+        return this.noDataText || Table_1.i18nBundle.getText(TABLE_NO_DATA);
+    }
+    get _ariaLabel() {
+        return getEffectiveAriaLabelText(this) || undefined;
+    }
+    get _ariaDescription() {
+        return this._getSelection()?.getAriaDescriptionForTable();
+    }
+    get _ariaRowCount() {
+        return this._getVirtualizer()?.rowCount || this.rows.length + 1;
+    }
+    get _ariaColCount() {
+        if (!this.headerRow[0]) {
+            return 0;
+        }
+        let ariaColCount = this.headerRow[0]._visibleCells.length;
+        if (this._isRowSelectorRequired) {
+            ariaColCount++;
+        }
+        if (this.rowActionCount > 0) {
+            ariaColCount++;
+        }
+        if (this.headerRow[0]._popinCells.length > 0) {
+            ariaColCount++;
+        }
+        return ariaColCount;
+    }
+    get _ariaMultiSelectable() {
+        const selection = this._getSelection();
+        return (selection?.isSelectable() && this.rows.length) ? selection.isMultiSelectable() : undefined;
+    }
+    get isTable() {
+        return true;
+    }
+};
+__decorate([
+    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, "accessibleName", void 0);
+__decorate([
+    property()
+], Table.prototype, "accessibleNameRef", void 0);
+__decorate([
+    property()
+], Table.prototype, "noDataText", void 0);
+__decorate([
+    property()
+], Table.prototype, "overflowMode", void 0);
+__decorate([
+    property({ type: Boolean })
+], Table.prototype, "loading", void 0);
+__decorate([
+    property({ type: Number })
+], Table.prototype, "loadingDelay", void 0);
+__decorate([
+    property({ type: Number })
+], Table.prototype, "rowActionCount", void 0);
+__decorate([
+    property({ type: Boolean })
+], Table.prototype, "alternateRowColors", void 0);
+__decorate([
+    property()
+], Table.prototype, "stickyTop", void 0);
+__decorate([
+    property({ type: Number, noAttribute: true })
+], Table.prototype, "_invalidate", void 0);
+__decorate([
+    property({ type: Boolean, noAttribute: true })
+], Table.prototype, "_renderNavigated", void 0);
+__decorate([
+    query("[ui5-drop-indicator]")
+], Table.prototype, "dropIndicatorDOM", void 0);
+__decorate([
+    query("#no-data-row")
+], Table.prototype, "_noDataRow", void 0);
+__decorate([
+    query("#table-end-row")
+], Table.prototype, "_endRow", void 0);
+__decorate([
+    query("#table")
+], Table.prototype, "_tableElement", void 0);
+__decorate([
+    query("#before")
+], Table.prototype, "_beforeElement", void 0);
+__decorate([
+    query("#after")
+], Table.prototype, "_afterElement", void 0);
+__decorate([
+    query("#loading")
+], Table.prototype, "_loadingElement", void 0);
+__decorate([
+    i18n("@ui5/webcomponents")
+], Table, "i18nBundle", void 0);
+Table = Table_1 = __decorate([
+    customElement({
+        tag: "ui5-table",
+        renderer: jsxRenderer,
+        styles: TableStyles,
+        template: TableTemplate,
+        fastNavigation: true,
+    })
+    /**
+     * 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
+     */
+    ,
+    eventStrict("row-click", {
+        bubbles: false,
+    })
+    /**
+     * 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
+     */
+    ,
+    eventStrict("move-over", {
+        cancelable: true,
+        bubbles: true,
+    })
+    /**
+     * Fired when a movable list item is dropped onto a drop target.
+     *
+     * **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
+     */
+    ,
+    eventStrict("move", {
+        bubbles: true,
+    })
+    /**
+     * 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
+     */
+    ,
+    eventStrict("row-action-click", {
+        bubbles: false,
+    })
+], Table);
 Table.define();
-
 export default Table;
+//# sourceMappingURL=Table.js.map