@ui5/webcomponents 0.0.0-0742854fd → 0.0.0-07d38e78e

package/dist/List.js

@@ -1,783 +1,995 @@
+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 List_1;
 import UI5Element from "@ui5/webcomponents-base/dist/UI5Element.js";
 import litRender from "@ui5/webcomponents-base/dist/renderer/LitRenderer.js";
+import ResizeHandler from "@ui5/webcomponents-base/dist/delegate/ResizeHandler.js";
 import ItemNavigation from "@ui5/webcomponents-base/dist/delegate/ItemNavigation.js";
-import { getLastTabbableElement } from "@ui5/webcomponents-base/dist/util/TabbableElements.js";
-import { isTabNext } from "@ui5/webcomponents-base/dist/Keys.js";
+import property from "@ui5/webcomponents-base/dist/decorators/property.js";
+import event from "@ui5/webcomponents-base/dist/decorators/event.js";
+import customElement from "@ui5/webcomponents-base/dist/decorators/customElement.js";
+import slot from "@ui5/webcomponents-base/dist/decorators/slot.js";
+import { renderFinished } from "@ui5/webcomponents-base/dist/Render.js";
+import { isTabNext, isSpace, isEnter, isTabPrevious, } from "@ui5/webcomponents-base/dist/Keys.js";
+import Integer from "@ui5/webcomponents-base/dist/types/Integer.js";
+import DragRegistry from "@ui5/webcomponents-base/dist/util/dragAndDrop/DragRegistry.js";
+import findClosestPosition from "@ui5/webcomponents-base/dist/util/dragAndDrop/findClosestPosition.js";
 import NavigationMode from "@ui5/webcomponents-base/dist/types/NavigationMode.js";
 import { getEffectiveAriaLabelText } from "@ui5/webcomponents-base/dist/util/AriaLabelHelper.js";
-import ListMode from "./types/ListMode.js";
+import getNormalizedTarget from "@ui5/webcomponents-base/dist/util/getNormalizedTarget.js";
+import getEffectiveScrollbarStyle from "@ui5/webcomponents-base/dist/util/getEffectiveScrollbarStyle.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 Orientation from "@ui5/webcomponents-base/dist/types/Orientation.js";
+import MovePlacement from "@ui5/webcomponents-base/dist/types/MovePlacement.js";
+import ListSelectionMode from "./types/ListSelectionMode.js";
+import ListGrowingMode from "./types/ListGrowingMode.js";
+import ListAccessibleRole from "./types/ListAccessibleRole.js";
+import "./ListItemBase.js";
+import DropIndicator from "./DropIndicator.js";
 import ListSeparators from "./types/ListSeparators.js";
 import BusyIndicator from "./BusyIndicator.js";
-
 // Template
 import ListTemplate from "./generated/templates/ListTemplate.lit.js";
-
 // Styles
 import listCss from "./generated/themes/List.css.js";
-
-const BUSYINDICATOR_HEIGHT = 48; // px
+import browserScrollbarCSS from "./generated/themes/BrowserScrollbar.css.js";
+// Texts
+import { LOAD_MORE_TEXT, ARIA_LABEL_LIST_SELECTABLE, ARIA_LABEL_LIST_MULTISELECTABLE, ARIA_LABEL_LIST_DELETABLE, } from "./generated/i18n/i18n-defaults.js";
+import "./CheckBox.js";
+import "./RadioButton.js";
+import ListItemGroup, { isInstanceOfListItemGroup } from "./ListItemGroup.js";
 const INFINITE_SCROLL_DEBOUNCE_RATE = 250; // ms
-
-/**
- * @public
- */
-const metadata = {
-	tag: "ui5-list",
-	managedSlots: true,
-	slots: /** @lends sap.ui.webcomponents.main.List.prototype */ {
-
-		/**
-		 * Defines the <code>ui5-list</code> header.
-		 * <br><br>
-		 * <b>Note:</b> When <code>header</code> is set, the
-		 * <code>headerText</code> property is ignored.
-		 *
-		 * @type {HTMLElement[]}
-		 * @slot
-		 * @public
-		 */
-		header: {
-			type: HTMLElement,
-		},
-
-		/**
-		 * Defines the items of the <code>ui5-list</code>.
-		 * <br><br>
-		 * <b>Note:</b> Use <code>ui5-li</code>, <code>ui5-li-custom</code>, and <code>ui5-li-groupheader</code> for the intended design.
-		 *
-		 * @type {HTMLElement[]}
-		 * @slot
-		 * @public
-		 */
-		"default": {
-			propertyName: "items",
-			type: HTMLElement,
-		},
-	},
-	properties: /** @lends  sap.ui.webcomponents.main.List.prototype */ {
-
-		/**
-		 * Defines the <code>ui5-list</code> header text.
-		 * <br><br>
-		 * <b>Note:</b> If <code>header</code> is set this property is ignored.
-		 *
-		 * @type {string}
-		 * @defaultvalue ""
-		 * @public
-		 */
-		headerText: {
-			type: String,
-		},
-
-		/**
-		 * Defines the footer text.
-		 *
-		 * @type {string}
-		 * @defaultvalue ""
-		 * @public
-		 */
-		footerText: {
-			type: String,
-		},
-
-		/**
-		 * Determines whether the list items are indented.
-		 *
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @public
-		 */
-		inset: {
-			type: Boolean,
-		},
-
-		/**
-		 * Defines the mode of the <code>ui5-list</code>.
-		 * <br><br>
-		 * <b>Note:</b> Available options are <code>None</code>, <code>SingleSelect</code>, <code>SingleSelectBegin</code>,
-		 * <code>SingleSelectEnd</code>, <code>MultiSelect</code>, and <code>Delete</code>.
-		 *
-		 * @type {ListMode}
-		 * @defaultvalue "None"
-		 * @public
-		 */
-		mode: {
-			type: ListMode,
-			defaultValue: ListMode.None,
-		},
-
-		/**
-		 * Defines the text that is displayed when the <code>ui5-list</code> contains no items.
-		 *
-		 * @type {string}
-		 * @defaultvalue ""
-		 * @public
-		 */
-		noDataText: {
-			type: String,
-		},
-
-		/**
-		 * Defines the item separator style that is used.
-		 * <br><br>
-		 * <b>Notes:</b>
-		 * <ul>
-		 * <li>Avalaible options are <code>All</code>, <code>Inner</code>, and <code>None</code>.</li>
-		 * <li>When set to <code>None</code>, none of the items are separated by horizontal lines.</li>
-		 * <li>When set to <code>Inner</code>, the first item doesn't have a top separator and the last
-		 * item doesn't have a bottom separator.</li>
-		 * </ul>
-		 *
-		 * @type {ListSeparators}
-		 * @defaultvalue "All"
-		 * @public
-		 */
-		separators: {
-			type: ListSeparators,
-			defaultValue: ListSeparators.All,
-		},
-
-		/**
-		 * Defines if the component would fire the <code>load-more</code> event
-		 * when the user scrolls to the bottom of the list, and helps achieving an "infinite scroll" effect
-		 * by adding new items each time.
-		 *
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @public
-		 * @since 1.0.0-rc.6
-		 */
-		infiniteScroll: {
-			type: Boolean,
-		},
-
-		/**
-		 * Defines if the component would display a loading indicator at the bottom of the list.
-		 * It's especially useful, when combined with <code>infiniteScroll</code>.
-		 *
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @public
-		 * @since 1.0.0-rc.6
-		 */
-		busy: {
-			type: Boolean,
-		},
-
-		/**
-		 * @type {String}
-		 * @defaultvalue ""
-		 * @private
-		 * @since 1.0.0-rc.8
-		 */
-		ariaLabel: {
-			type: String,
-		},
-
-		/**
-		 * Receives id(or many ids) of the elements that label the input
-		 *
-		 * @type {String}
-		 * @defaultvalue ""
-		 * @private
-		 * @since 1.0.0-rc.8
-		 */
-		ariaLabelledby: {
-			type: String,
-			defaultValue: "",
-		},
-
-		/**
-		 * Used to externally manipulate the role of the list
-		 *
-		 * @private
-		 * @type {String}
-		 * @defaultvalue "listbox"
-		 * @since 1.0.0-rc.9
-		 */
-		role: {
-			type: String,
-			defaultValue: "listbox",
-		},
-	},
-	events: /** @lends  sap.ui.webcomponents.main.List.prototype */ {
-
-		/**
-		 * Fired when an item is activated, unless the item's <code>type</code> property
-		 * is set to <code>Inactive</code>.
-		 *
-		 * @event sap.ui.webcomponents.main.List#item-click
-		 * @param {HTMLElement} item the clicked item.
-		 * @public
-		 */
-		"item-click": {
-			detail: {
-				item: { type: HTMLElement },
-			},
-		},
-
-		/**
-		 * Fired when the <code>Close</code> button of any item is clicked
-		 * <br><br>
-		 * <b>Note:</b> This event is applicable to <code>ui5-li-notification</code> items only,
-		 * not to be confused with <code>item-delete</code>.
-		 *
-		 * @event sap.ui.webcomponents.main.List#item-close
-		 * @param {HTMLElement} item the item about to be closed.
-		 * @public
-		 * @since 1.0.0-rc.8
-		 */
-		"item-close": {
-			detail: {
-				item: { type: HTMLElement },
-			},
-		},
-
-		/**
-		 * Fired when the <code>Toggle</code> button of any item is clicked.
-		 * <br><br>
-		 * <b>Note:</b> This event is applicable to <code>ui5-li-notification-group</code> items only.
-		 *
-		 * @event sap.ui.webcomponents.main.List#item-toggle
-		 * @param {HTMLElement} item the toggled item.
-		 * @public
-		 * @since 1.0.0-rc.8
-		 */
-		"item-toggle": {
-			detail: {
-				item: { type: HTMLElement },
-			},
-		},
-
-		/**
-		 * Fired when the Delete button of any item is pressed.
-		 * <br><br>
-		 * <b>Note:</b> A Delete button is displayed on each item,
-		 * when the <code>ui5-list</code> <code>mode</code> property is set to <code>Delete</code>.
-		 *
-		 * @event sap.ui.webcomponents.main.List#item-delete
-		 * @param {HTMLElement} item the deleted item.
-		 * @public
-		 */
-		"item-delete": {
-			detail: {
-				item: { type: HTMLElement },
-			},
-		},
-
-		/**
-		 * Fired when selection is changed by user interaction
-		 * in <code>SingleSelect</code>, <code>SingleSelectBegin</code>, <code>SingleSelectEnd</code> and <code>MultiSelect</code> modes.
-		 *
-		 * @event sap.ui.webcomponents.main.List#selection-change
-		 * @param {Array} selectedItems An array of the selected items.
-		 * @param {Array} previouslySelectedItems An array of the previously selected items.
-		 * @public
-		 */
-		"selection-change": {
-			detail: {
-				selectedItems: { type: Array },
-				previouslySelectedItems: { type: Array },
-				selectionComponentPressed: { type: Boolean }, // protected, indicates if the user used the selection components to change the selection
-			},
-		},
-
-		/**
-		 * Fired when the user scrolls to the bottom of the list.
-		 * <br><br>
-		 * <b>Note:</b> The event is fired when the <code>infiniteScroll</code> property is enabled.
-		 *
-		 * @event sap.ui.webcomponents.main.List#load-more
-		 * @public
-		 * @since 1.0.0-rc.6
-		 */
-		"load-more": {},
-	},
-};
-
+const PAGE_UP_DOWN_SIZE = 10;
 /**
  * @class
  *
- * <h3 class="comment-api-title">Overview</h3>
+ * ### Overview
  *
- * The <code>ui5-list</code> component allows displaying a list of items, advanced keyboard
+ * The `ui5-list` component allows displaying a list of items, advanced keyboard
  * handling support for navigating between items, and predefined modes to improve the development efficiency.
- * <br><br>
- * The <code>ui5-list</code> is а container for the available list items:
- * <ul>
- * <li><code>ui5-li</code></li>
- * <li><code>ui5-li-custom</code></li>
- * <li><code>ui5-li-groupheader</code></li>
- * </ul>
- * <br><br>
+ *
+ * The `ui5-list` is a container for the available list items:
+ *
+ * - `ui5-li`
+ * - `ui5-li-custom`
+ * - `ui5-li-group`
+ *
  * To benefit from the built-in selection mechanism, you can use the available
  * selection modes, such as
- * <code>SingleSelect</code>, <code>MultiSelect</code> and <code>Delete</code>.
- * <br><br>
- * Additionally, the <code>ui5-list</code> provides header, footer, and customization for the list item separators.
+ * `Single`, `Multiple` and `Delete`.
+ *
+ * Additionally, the `ui5-list` provides header, footer, and customization for the list item separators.
  *
- * <h3>ES6 Module Import</h3>
+ * ### Keyboard Handling
  *
- * <code>import "@ui5/webcomponents/dist/List.js";</code>
- * <br>
- * <code>import "@ui5/webcomponents/dist/StandardListItem.js";</code> (for <code>ui5-li</code>)
- * <br>
- * <code>import "@ui5/webcomponents/dist/CustomListItem.js";</code> (for <code>ui5-li-custom</code>)
- * <br>
- * <code>import "@ui5/webcomponents/dist/GroupHeaderListItem.js";</code> (for <code>ui5-li-groupheader</code>)
+ * #### Basic Navigation
+ * The `ui5-list` provides advanced keyboard handling.
+ * When a list is focused the user can use the following keyboard
+ * shortcuts in order to perform a navigation:
  *
+ * - [Up] or [Down] - Navigates up and down the items
+ * - [Home] - Navigates to first item
+ * - [End] - Navigates to the last item
+ *
+ * The user can use the following keyboard shortcuts to perform actions (such as select, delete),
+ * when the `selectionMode` property is in use:
+ *
+ * - [Space] - Select an item (if `type` is 'Active') when `selectionMode` is selection
+ * - [Delete] - Delete an item if `selectionMode` property is `Delete`
+ *
+ * #### 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"`
+ *
+ * ### ES6 Module Import
+ *
+ * `import "@ui5/webcomponents/dist/List.js";`
+ *
+ * `import "@ui5/webcomponents/dist/StandardListItem.js";` (for `ui5-li`)
+ *
+ * `import "@ui5/webcomponents/dist/CustomListItem.js";` (for `ui5-li-custom`)
+ *
+ * `import "@ui5/webcomponents/dist/ListItemGroup.js";` (for `ui5-li-group`)
  * @constructor
- * @author SAP SE
- * @alias sap.ui.webcomponents.main.List
  * @extends UI5Element
- * @tagname ui5-list
- * @appenddocs StandardListItem CustomListItem GroupHeaderListItem
  * @public
  */
-class List extends UI5Element {
-	static get metadata() {
-		return metadata;
-	}
-
-	static get render() {
-		return litRender;
-	}
-
-	static get template() {
-		return ListTemplate;
-	}
-
-	static get styles() {
-		return listCss;
-	}
-
-	constructor() {
-		super();
-		this.initItemNavigation();
-
-		// Stores the last focused item within the internal ul element.
-		this._previouslyFocusedItem = null;
-
-		// Indicates that the List is forwarding the focus before or after the internal ul.
-		this._forwardingFocus = false;
-
-		this._previouslySelectedItem = null;
-
-		this.addEventListener("ui5-_press", this.onItemPress.bind(this));
-		this.addEventListener("ui5-close", this.onItemClose.bind(this));
-		this.addEventListener("ui5-toggle", this.onItemToggle.bind(this));
-		this.addEventListener("ui5-_focused", this.onItemFocused.bind(this));
-		this.addEventListener("ui5-_forward-after", this.onForwardAfter.bind(this));
-		this.addEventListener("ui5-_forward-before", this.onForwardBefore.bind(this));
-		this.addEventListener("ui5-_selection-requested", this.onSelectionRequested.bind(this));
-		this.addEventListener("ui5-_focus-requested", this.focusUploadCollectionItem.bind(this));
-	}
-
-	get shouldRenderH1() {
-		return !this.header.length && this.headerText;
-	}
-
-	get headerID() {
-		return `${this._id}-header`;
-	}
-
-	get showNoDataText() {
-		return this.items.length === 0 && this.noDataText;
-	}
-
-	get showBusy() {
-		return this.busy || this.infiniteScroll;
-	}
-
-	get isMultiSelect() {
-		return this.mode === ListMode.MultiSelect;
-	}
-
-	get ariaLabelledBy() {
-		if (this.ariaLabelledby || this.ariaLabel) {
-			return undefined;
-		}
-
-		return this.shouldRenderH1 ? this.headerID : undefined;
-	}
-
-	get ariaLabelТxt() {
-		return getEffectiveAriaLabelText(this);
-	}
-
-	onBeforeRendering() {
-		this.prepareListItems();
-	}
-
-	initItemNavigation() {
-		this._itemNavigation = new ItemNavigation(this, {
-			navigationMode: NavigationMode.Vertical,
-		});
-
-		this._itemNavigation.getItemsCallback = () => this.getSlottedNodes("items");
-	}
-
-	prepareListItems() {
-		const slottedItems = this.getSlottedNodes("items");
-
-		slottedItems.forEach((item, key) => {
-			const isLastChild = key === slottedItems.length - 1;
-			const showBottomBorder = this.separators === ListSeparators.All
-				|| (this.separators === ListSeparators.Inner && !isLastChild);
-
-			item._mode = this.mode;
-			item.hasBorder = showBottomBorder;
-		});
-
-		this._previouslySelectedItem = null;
-	}
-
-	/*
-	* ITEM SELECTION BASED ON THE CURRENT MODE
-	*/
-	onSelectionRequested(event) {
-		const previouslySelectedItems = this.getSelectedItems();
-		let selectionChange = false;
-		this._selectionRequested = true;
-
-		if (this[`handle${this.mode}`]) {
-			selectionChange = this[`handle${this.mode}`](event.detail.item, event.detail.selected);
-		}
-
-		if (selectionChange) {
-			this.fireEvent("selection-change", {
-				selectedItems: this.getSelectedItems(),
-				previouslySelectedItems,
-				selectionComponentPressed: event.detail.selectionComponentPressed,
-				key: event.detail.key,
-			});
-		}
-	}
-
-	handleSingleSelect(item) {
-		if (item.selected) {
-			return false;
-		}
-
-		this.deselectSelectedItems();
-		item.selected = true;
-
-		return true;
-	}
-
-	handleSingleSelectBegin(item) {
-		return this.handleSingleSelect(item);
-	}
-
-	handleSingleSelectEnd(item) {
-		return this.handleSingleSelect(item);
-	}
-
-	handleSingleSelectAuto(item) {
-		return this.handleSingleSelect(item);
-	}
-
-	handleMultiSelect(item, selected) {
-		item.selected = selected;
-		return true;
-	}
-
-	handleDelete(item) {
-		this.fireEvent("item-delete", { item });
-	}
-
-	deselectSelectedItems() {
-		this.getSelectedItems().forEach(item => { item.selected = false; });
-	}
-
-	getSelectedItems() {
-		return this.getSlottedNodes("items").filter(item => item.selected);
-	}
-
-	getFirstSelectedItem() {
-		const slottedItems = this.getSlottedNodes("items");
-		let firstSelectedItem = null;
-
-		for (let i = 0; i < slottedItems.length; i++) {
-			if (slottedItems[i].selected) {
-				firstSelectedItem = slottedItems[i];
-				break;
-			}
-		}
-
-		return firstSelectedItem;
-	}
-
-	_onkeydown(event) {
-		if (isTabNext(event)) {
-			this._handleTabNext(event);
-		}
-	}
-
-	/*
-	* KEYBOARD SUPPORT
-	*/
-	_handleTabNext(event) {
-		// If forward navigation is performed, we check if the List has headerToolbar.
-		// If yes - we check if the target is at the last tabbable element of the headerToolbar
-		// to forward correctly the focus to the selected, previously focused or to the first list item.
-		let lastTabbableEl;
-		const target = this.getNormalizedTarget(event.target);
-
-		if (this.headerToolbar) {
-			lastTabbableEl = this.getHeaderToolbarLastTabbableElement();
-		}
-
-		if (!lastTabbableEl) {
-			return;
-		}
-
-		if (lastTabbableEl === target) {
-			if (this.getFirstSelectedItem()) {
-				this.focusFirstSelectedItem();
-			} else if (this.getPreviouslyFocusedItem()) {
-				this.focusPreviouslyFocusedItem();
-			} else {
-				this.focusFirstItem();
-			}
-
-			event.stopImmediatePropagation();
-			event.preventDefault();
-		}
-	}
-
-	_onScroll(event) {
-		if (!this.infiniteScroll) {
-			return;
-		}
-		this.debounce(this.loadMore.bind(this, event.target), INFINITE_SCROLL_DEBOUNCE_RATE);
-	}
-
-	_onfocusin(event) {
-		// If the focusin event does not origin from one of the 'triggers' - ignore it.
-		if (!this.isForwardElement(this.getNormalizedTarget(event.target))) {
-			event.stopImmediatePropagation();
-			return;
-		}
-
-		// The focus arrives in the List for the first time.
-		// If there is selected item - focus it or focus the first item.
-		if (!this.getPreviouslyFocusedItem()) {
-			if (this.getFirstSelectedItem()) {
-				this.focusFirstSelectedItem();
-			} else {
-				this.focusFirstItem();
-			}
-
-			event.stopImmediatePropagation();
-			return;
-		}
-
-		// The focus returns to the List,
-		// focus the first selected item or the previously focused element.
-		if (!this.getForwardingFocus()) {
-			if (this.getFirstSelectedItem()) {
-				this.focusFirstSelectedItem();
-			} else {
-				this.focusPreviouslyFocusedItem();
-			}
-		}
-
-		this.setForwardingFocus(false);
-	}
-
-	isForwardElement(node) {
-		const nodeId = node.id;
-
-		if (this._id === nodeId || this.getBeforeElement().id === nodeId) {
-			return true;
-		}
-
-		return this.getAfterElement().id === nodeId;
-	}
-
-	onItemFocused(event) {
-		const target = event.target;
-
-		this._itemNavigation.update(target);
-		this.fireEvent("item-focused", { item: target });
-
-		if (this.mode === ListMode.SingleSelectAuto) {
-			this.onSelectionRequested({
-				detail: {
-					item: target,
-					selectionComponentPressed: false,
-					selected: true,
-					key: event.detail.key,
-				},
-			});
-		}
-	}
-
-	onItemPress(event) {
-		const pressedItem = event.detail.item;
-
-		if (!this._selectionRequested && this.mode !== ListMode.Delete) {
-			this._selectionRequested = true;
-			this.onSelectionRequested({
-				detail: {
-					item: pressedItem,
-					selectionComponentPressed: false,
-					selected: !pressedItem.selected,
-					key: event.detail.key,
-				},
-			});
-		}
-
-		this.fireEvent("item-press", { item: pressedItem });
-		this.fireEvent("item-click", { item: pressedItem });
-
-		this._selectionRequested = false;
-	}
-
-	// This is applicable to NoficationListItem
-	onItemClose(event) {
-		this.fireEvent("item-close", { item: event.detail.item });
-	}
-
-	onItemToggle(event) {
-		this.fireEvent("item-toggle", { item: event.detail.item });
-	}
-
-	onForwardBefore(event) {
-		this.setPreviouslyFocusedItem(event.target);
-		this.focusBeforeElement();
-	}
-
-	onForwardAfter(event) {
-		this.setPreviouslyFocusedItem(event.target);
-		this.focusAfterElement();
-	}
-
-	focusBeforeElement() {
-		this.setForwardingFocus(true);
-		this.getBeforeElement().focus();
-	}
-
-	focusAfterElement() {
-		this.setForwardingFocus(true);
-		this.getAfterElement().focus();
-	}
-
-	focusFirstItem() {
-		const firstItem = this.getFirstItem();
-
-		if (firstItem) {
-			firstItem.focus();
-		}
-	}
-
-	focusPreviouslyFocusedItem() {
-		const previouslyFocusedItem = this.getPreviouslyFocusedItem();
-
-		if (previouslyFocusedItem) {
-			previouslyFocusedItem.focus();
-		}
-	}
-
-	focusFirstSelectedItem() {
-		const firstSelectedItem = this.getFirstSelectedItem();
-
-		if (firstSelectedItem) {
-			firstSelectedItem.focus();
-		}
-	}
-
-	focusItem(item) {
-		item.focus();
-	}
-
-
-	focusUploadCollectionItem(event) {
-		setTimeout(() => {
-			this.setPreviouslyFocusedItem(event.target);
-			this.focusPreviouslyFocusedItem();
-		}, 0);
-	}
-
-	setForwardingFocus(forwardingFocus) {
-		this._forwardingFocus = forwardingFocus;
-	}
-
-	getForwardingFocus() {
-		return this._forwardingFocus;
-	}
-
-	setPreviouslyFocusedItem(item) {
-		this._previouslyFocusedItem = item;
-	}
-
-	getPreviouslyFocusedItem() {
-		return this._previouslyFocusedItem;
-	}
-
-	getFirstItem() {
-		const slottedItems = this.getSlottedNodes("items");
-		return !!slottedItems.length && slottedItems[0];
-	}
-
-	getAfterElement() {
-		if (!this._afterElement) {
-			this._afterElement = this.shadowRoot.querySelector(`#${this._id}-after`);
-		}
-		return this._afterElement;
-	}
-
-	getBeforeElement() {
-		if (!this._beforeElement) {
-			this._beforeElement = this.shadowRoot.querySelector(`#${this._id}-before`);
-		}
-		return this._beforeElement;
-	}
-
-	getHeaderToolbarLastTabbableElement() {
-		return getLastTabbableElement(this.headerToolbar.getDomRef()) || this.headerToolbar.getDomRef();
-	}
-
-	getNormalizedTarget(target) {
-		let focused = target;
-
-		if (target.shadowRoot && target.shadowRoot.activeElement) {
-			focused = target.shadowRoot.activeElement;
-		}
-
-		return focused;
-	}
-
-	loadMore(el) {
-		const scrollTop = el.scrollTop;
-		const height = el.offsetHeight;
-		const scrollHeight = el.scrollHeight;
-
-		if (this.previousScrollPosition > scrollTop) { // skip scrolling upwards
-			this.previousScrollPosition = scrollTop;
-			return;
-		}
-		this.previousScrollPosition = scrollTop;
-
-		if (scrollHeight - BUSYINDICATOR_HEIGHT <= height + scrollTop) {
-			this.fireEvent("load-more");
-		}
-	}
-
-	debounce(fn, delay) {
-		clearTimeout(this.debounceInterval);
-		this.debounceInterval = setTimeout(() => {
-			this.debounceInterval = null;
-			fn();
-		}, delay);
-	}
-
-	static get dependencies() {
-		return [BusyIndicator];
-	}
-}
-
+let List = List_1 = class List extends UI5Element {
+    static async onDefine() {
+        List_1.i18nBundle = await getI18nBundle("@ui5/webcomponents");
+    }
+    constructor() {
+        super();
+        this._previouslyFocusedItem = null;
+        // Indicates that the List is forwarding the focus before or after the internal ul.
+        this._forwardingFocus = false;
+        // Indicates that the List has already subscribed for resize.
+        this.resizeListenerAttached = false;
+        // Indicates if the IntersectionObserver started observing the List
+        this.listEndObserved = false;
+        this._itemNavigation = new ItemNavigation(this, {
+            skipItemsSize: PAGE_UP_DOWN_SIZE,
+            navigationMode: NavigationMode.Vertical,
+            getItemsCallback: () => this.getEnabledItems(),
+        });
+        this._handleResize = this.checkListInViewport.bind(this);
+        this._handleResize = this.checkListInViewport.bind(this);
+        // Indicates the List bottom most part has been detected by the IntersectionObserver
+        // for the first time.
+        this.initialIntersection = true;
+        this.onItemFocusedBound = this.onItemFocused.bind(this);
+        this.onForwardAfterBound = this.onForwardAfter.bind(this);
+        this.onForwardBeforeBound = this.onForwardBefore.bind(this);
+        this.onItemTabIndexChangeBound = this.onItemTabIndexChange.bind(this);
+    }
+    /**
+     * Returns an array containing the list item instances without the groups in a flat structure.
+     * @default []
+     * @since 2.0.0
+     * @public
+     */
+    get listItems() {
+        return this.getItems();
+    }
+    onEnterDOM() {
+        DragRegistry.subscribe(this);
+    }
+    onExitDOM() {
+        this.unobserveListEnd();
+        this.resizeListenerAttached = false;
+        ResizeHandler.deregister(this.getDomRef(), this._handleResize);
+        DragRegistry.unsubscribe(this);
+    }
+    onBeforeRendering() {
+        this.detachGroupHeaderEvents();
+        this.prepareListItems();
+    }
+    onAfterRendering() {
+        this.attachGroupHeaderEvents();
+        if (this.growsOnScroll) {
+            this.observeListEnd();
+        }
+        else if (this.listEndObserved) {
+            this.unobserveListEnd();
+        }
+        if (this.grows) {
+            this.checkListInViewport();
+            this.attachForResize();
+        }
+    }
+    attachGroupHeaderEvents() {
+        // events fired by the group headers are not bubbling through the shadow
+        // dom of the groups because of capture: false of the custom events
+        this.getItems().forEach(item => {
+            if (item.hasAttribute("ui5-li-group-header")) {
+                item.addEventListener("ui5-_focused", this.onItemFocusedBound);
+                item.addEventListener("ui5-_forward-after", this.onForwardAfterBound);
+                item.addEventListener("ui5-_forward-before", this.onForwardBeforeBound);
+                item.addEventListener("ui5-_tabindex-change", this.onItemTabIndexChangeBound);
+            }
+        });
+    }
+    detachGroupHeaderEvents() {
+        this.getItems().forEach(item => {
+            if (item.hasAttribute("ui5-li-group-header")) {
+                item.removeEventListener("ui5-_focused", this.onItemFocusedBound);
+                item.removeEventListener("ui5-_forward-after", this.onForwardAfterBound);
+                item.removeEventListener("ui5-_forward-before", this.onForwardBeforeBound);
+                item.removeEventListener("ui5-_tabindex-change", this.onItemTabIndexChangeBound);
+            }
+        });
+    }
+    attachForResize() {
+        if (!this.resizeListenerAttached) {
+            this.resizeListenerAttached = true;
+            ResizeHandler.register(this.getDomRef(), this._handleResize);
+        }
+    }
+    get shouldRenderH1() {
+        return !this.header.length && this.headerText;
+    }
+    get headerID() {
+        return `${this._id}-header`;
+    }
+    get modeLabelID() {
+        return `${this._id}-modeLabel`;
+    }
+    get listEndDOM() {
+        return this.shadowRoot.querySelector(".ui5-list-end-marker");
+    }
+    get dropIndicatorDOM() {
+        return this.shadowRoot.querySelector("[ui5-drop-indicator]");
+    }
+    get hasData() {
+        return this.getItems().length !== 0;
+    }
+    get showNoDataText() {
+        return !this.hasData && this.noDataText;
+    }
+    get isDelete() {
+        return this.selectionMode === ListSelectionMode.Delete;
+    }
+    get isSingleSelect() {
+        return [
+            ListSelectionMode.Single,
+            ListSelectionMode.SingleStart,
+            ListSelectionMode.SingleEnd,
+            ListSelectionMode.SingleAuto,
+        ].includes(this.selectionMode);
+    }
+    get isMultiple() {
+        return this.selectionMode === ListSelectionMode.Multiple;
+    }
+    get ariaLabelledBy() {
+        if (this.accessibleNameRef || this.accessibleName) {
+            return undefined;
+        }
+        const ids = [];
+        if (this.isMultiple || this.isSingleSelect || this.isDelete) {
+            ids.push(this.modeLabelID);
+        }
+        if (this.shouldRenderH1) {
+            ids.push(this.headerID);
+        }
+        return ids.length ? ids.join(" ") : undefined;
+    }
+    get ariaLabelTxt() {
+        return getEffectiveAriaLabelText(this);
+    }
+    get ariaLabelModeText() {
+        if (this.hasData) {
+            if (this.isMultiple) {
+                return List_1.i18nBundle.getText(ARIA_LABEL_LIST_MULTISELECTABLE);
+            }
+            if (this.isSingleSelect) {
+                return List_1.i18nBundle.getText(ARIA_LABEL_LIST_SELECTABLE);
+            }
+            if (this.isDelete) {
+                return List_1.i18nBundle.getText(ARIA_LABEL_LIST_DELETABLE);
+            }
+        }
+        return "";
+    }
+    get grows() {
+        return this.growing !== ListGrowingMode.None;
+    }
+    get growsOnScroll() {
+        return this.growing === ListGrowingMode.Scroll;
+    }
+    get growsWithButton() {
+        return this.growing === ListGrowingMode.Button;
+    }
+    get _growingButtonText() {
+        return this.growingButtonText || List_1.i18nBundle.getText(LOAD_MORE_TEXT);
+    }
+    get loadingIndPosition() {
+        if (!this.grows) {
+            return "absolute";
+        }
+        return this._inViewport ? "absolute" : "sticky";
+    }
+    get styles() {
+        return {
+            loadingInd: {
+                position: this.loadingIndPosition,
+            },
+        };
+    }
+    get listAccessibleRole() {
+        return this.accessibleRole.toLowerCase();
+    }
+    get classes() {
+        return {
+            root: {
+                "ui5-list-root": true,
+                "ui5-content-native-scrollbars": getEffectiveScrollbarStyle(),
+            },
+        };
+    }
+    prepareListItems() {
+        const slottedItems = this.getItemsForProcessing();
+        slottedItems.forEach((item, key) => {
+            const isLastChild = key === slottedItems.length - 1;
+            const showBottomBorder = this.separators === ListSeparators.All
+                || (this.separators === ListSeparators.Inner && !isLastChild);
+            if (item.hasConfigurableMode) {
+                item._selectionMode = this.selectionMode;
+            }
+            item.hasBorder = showBottomBorder;
+        });
+    }
+    async observeListEnd() {
+        if (!this.listEndObserved) {
+            await renderFinished();
+            this.getIntersectionObserver().observe(this.listEndDOM);
+            this.listEndObserved = true;
+        }
+    }
+    unobserveListEnd() {
+        if (this.growingIntersectionObserver) {
+            this.growingIntersectionObserver.disconnect();
+            this.growingIntersectionObserver = null;
+            this.listEndObserved = false;
+        }
+    }
+    onInteresection(entries) {
+        if (this.initialIntersection) {
+            this.initialIntersection = false;
+            return;
+        }
+        entries.forEach(entry => {
+            if (entry.isIntersecting) {
+                debounce(this.loadMore.bind(this), INFINITE_SCROLL_DEBOUNCE_RATE);
+            }
+        });
+    }
+    /*
+    * ITEM SELECTION BASED ON THE CURRENT MODE
+    */
+    onSelectionRequested(e) {
+        const previouslySelectedItems = this.getSelectedItems();
+        let selectionChange = false;
+        this._selectionRequested = true;
+        if (this.selectionMode !== ListSelectionMode.None && this[`handle${this.selectionMode}`]) {
+            selectionChange = this[`handle${this.selectionMode}`](e.detail.item, !!e.detail.selected);
+        }
+        if (selectionChange) {
+            const changePrevented = !this.fireEvent("selection-change", {
+                selectedItems: this.getSelectedItems(),
+                previouslySelectedItems,
+                selectionComponentPressed: e.detail.selectionComponentPressed,
+                targetItem: e.detail.item,
+                key: e.detail.key,
+            }, true);
+            if (changePrevented) {
+                this._revertSelection(previouslySelectedItems);
+            }
+        }
+    }
+    handleSingle(item) {
+        if (item.selected) {
+            return false;
+        }
+        this.deselectSelectedItems();
+        item.selected = true;
+        return true;
+    }
+    handleSingleStart(item) {
+        return this.handleSingle(item);
+    }
+    handleSingleEnd(item) {
+        return this.handleSingle(item);
+    }
+    handleSingleAuto(item) {
+        return this.handleSingle(item);
+    }
+    handleMultiple(item, selected) {
+        item.selected = selected;
+        return true;
+    }
+    handleDelete(item) {
+        this.fireEvent("item-delete", { item });
+        return true;
+    }
+    deselectSelectedItems() {
+        this.getSelectedItems().forEach(item => { item.selected = false; });
+    }
+    getSelectedItems() {
+        return this.getItems().filter(item => item.selected);
+    }
+    getEnabledItems() {
+        return this.getItems().filter(item => item._focusable);
+    }
+    getItems() {
+        // drill down when we see ui5-li-group and get the items
+        const items = [];
+        const slottedItems = this.getSlottedNodes("items");
+        slottedItems.forEach(item => {
+            if (isInstanceOfListItemGroup(item)) {
+                const groupItems = [item.groupHeaderItem, ...item.items].filter(Boolean);
+                items.push(...groupItems);
+            }
+            else {
+                items.push(item);
+            }
+        });
+        return items;
+    }
+    getItemsForProcessing() {
+        return this.getItems();
+    }
+    _revertSelection(previouslySelectedItems) {
+        this.getItems().forEach((item) => {
+            const oldSelection = previouslySelectedItems.indexOf(item) !== -1;
+            const multiSelectCheckBox = item.shadowRoot.querySelector(".ui5-li-multisel-cb");
+            const singleSelectRadioButton = item.shadowRoot.querySelector(".ui5-li-singlesel-radiobtn");
+            item.selected = oldSelection;
+            if (multiSelectCheckBox) {
+                multiSelectCheckBox.checked = oldSelection;
+            }
+            else if (singleSelectRadioButton) {
+                singleSelectRadioButton.checked = oldSelection;
+            }
+        });
+    }
+    _onkeydown(e) {
+        if (isTabNext(e)) {
+            this._handleTabNext(e);
+        }
+    }
+    _onLoadMoreKeydown(e) {
+        if (isSpace(e)) {
+            e.preventDefault();
+            this._loadMoreActive = true;
+        }
+        if (isEnter(e)) {
+            this._onLoadMoreClick();
+            this._loadMoreActive = true;
+        }
+        if (isTabNext(e)) {
+            this.focusAfterElement();
+        }
+        if (isTabPrevious(e)) {
+            if (this.getPreviouslyFocusedItem()) {
+                this.focusPreviouslyFocusedItem();
+            }
+            else {
+                this.focusFirstItem();
+            }
+            e.preventDefault();
+        }
+    }
+    _onLoadMoreKeyup(e) {
+        if (isSpace(e)) {
+            this._onLoadMoreClick();
+        }
+        this._loadMoreActive = false;
+    }
+    _onLoadMoreMousedown() {
+        this._loadMoreActive = true;
+    }
+    _onLoadMoreMouseup() {
+        this._loadMoreActive = false;
+    }
+    _onLoadMoreClick() {
+        this.loadMore();
+    }
+    checkListInViewport() {
+        this._inViewport = isElementInView(this.getDomRef());
+    }
+    loadMore() {
+        this.fireEvent("load-more");
+    }
+    /*
+    * KEYBOARD SUPPORT
+    */
+    _handleTabNext(e) {
+        let lastTabbableEl;
+        const target = getNormalizedTarget(e.target);
+        if (!lastTabbableEl) {
+            return;
+        }
+        if (lastTabbableEl === target) {
+            if (this.getFirstItem(x => x.selected && x._focusable)) {
+                this.focusFirstSelectedItem();
+            }
+            else if (this.getPreviouslyFocusedItem()) {
+                this.focusPreviouslyFocusedItem();
+            }
+            else {
+                this.focusFirstItem();
+            }
+            e.stopImmediatePropagation();
+            e.preventDefault();
+        }
+    }
+    _onfocusin(e) {
+        const target = getNormalizedTarget(e.target);
+        // If the focusin event does not origin from one of the 'triggers' - ignore it.
+        if (!this.isForwardElement(target)) {
+            e.stopImmediatePropagation();
+            return;
+        }
+        // The focus arrives in the List for the first time.
+        // If there is selected item - focus it or focus the first item.
+        if (!this.getPreviouslyFocusedItem()) {
+            if (this.growsWithButton && this.isForwardAfterElement(target)) {
+                this.focusGrowingButton();
+            }
+            else {
+                this.focusFirstItem();
+            }
+            e.stopImmediatePropagation();
+            return;
+        }
+        // The focus returns to the List,
+        // focus the first selected item or the previously focused element.
+        if (!this.getForwardingFocus()) {
+            if (this.growsWithButton && this.isForwardAfterElement(target)) {
+                this.focusGrowingButton();
+                e.stopImmediatePropagation();
+                return;
+            }
+            this.focusPreviouslyFocusedItem();
+            e.stopImmediatePropagation();
+        }
+        this.setForwardingFocus(false);
+    }
+    _ondragenter(e) {
+        e.preventDefault();
+    }
+    _ondragleave(e) {
+        if (e.relatedTarget instanceof Node && this.shadowRoot.contains(e.relatedTarget)) {
+            return;
+        }
+        this.dropIndicatorDOM.targetReference = null;
+    }
+    _ondragover(e) {
+        const draggedElement = DragRegistry.getDraggedElement();
+        if (!(e.target instanceof HTMLElement) || !draggedElement) {
+            return;
+        }
+        const closestPosition = findClosestPosition(this.items, e.clientY, Orientation.Vertical);
+        if (!closestPosition) {
+            this.dropIndicatorDOM.targetReference = null;
+            return;
+        }
+        let placements = closestPosition.placements;
+        if (closestPosition.element === draggedElement) {
+            placements = placements.filter(placement => placement !== MovePlacement.On);
+        }
+        const placementAccepted = placements.some(placement => {
+            const beforeItemMovePrevented = !this.fireEvent("move-over", {
+                source: {
+                    element: draggedElement,
+                },
+                destination: {
+                    element: closestPosition.element,
+                    placement,
+                },
+            }, true);
+            if (beforeItemMovePrevented) {
+                e.preventDefault();
+                this.dropIndicatorDOM.targetReference = closestPosition.element;
+                this.dropIndicatorDOM.placement = placement;
+                return true;
+            }
+            return false;
+        });
+        if (!placementAccepted) {
+            this.dropIndicatorDOM.targetReference = null;
+        }
+    }
+    _ondrop(e) {
+        e.preventDefault();
+        const draggedElement = DragRegistry.getDraggedElement();
+        this.fireEvent("move", {
+            source: {
+                element: draggedElement,
+            },
+            destination: {
+                element: this.dropIndicatorDOM.targetReference,
+                placement: this.dropIndicatorDOM.placement,
+            },
+        });
+        this.dropIndicatorDOM.targetReference = null;
+        draggedElement.focus();
+    }
+    isForwardElement(element) {
+        const elementId = element.id;
+        const beforeElement = this.getBeforeElement();
+        if (this._id === elementId || (beforeElement && beforeElement.id === elementId)) {
+            return true;
+        }
+        return this.isForwardAfterElement(element);
+    }
+    isForwardAfterElement(element) {
+        const elementId = element.id;
+        const afterElement = this.getAfterElement();
+        return afterElement && afterElement.id === elementId;
+    }
+    onItemTabIndexChange(e) {
+        const target = e.target;
+        this._itemNavigation.setCurrentItem(target);
+    }
+    onItemFocused(e) {
+        const target = e.target;
+        e.stopPropagation();
+        this._itemNavigation.setCurrentItem(target);
+        this.fireEvent("item-focused", { item: target });
+        if (this.selectionMode === ListSelectionMode.SingleAuto) {
+            const detail = {
+                item: target,
+                selectionComponentPressed: false,
+                selected: true,
+                key: e.detail.key,
+            };
+            this.onSelectionRequested({ detail });
+        }
+    }
+    onItemPress(e) {
+        const pressedItem = e.detail.item;
+        if (!this.fireEvent("item-click", { item: pressedItem }, true)) {
+            return;
+        }
+        if (!this._selectionRequested && this.selectionMode !== ListSelectionMode.Delete) {
+            this._selectionRequested = true;
+            const detail = {
+                item: pressedItem,
+                selectionComponentPressed: false,
+                selected: !pressedItem.selected,
+                key: e.detail.key,
+            };
+            this.onSelectionRequested({ detail });
+        }
+        this._selectionRequested = false;
+    }
+    // This is applicable to NotificationListItem
+    onItemClose(e) {
+        const target = e.target;
+        const shouldFireItemClose = target?.hasAttribute("ui5-li-notification") || target?.hasAttribute("ui5-li-notification-group");
+        if (shouldFireItemClose) {
+            this.fireEvent("item-close", { item: e.detail?.item });
+        }
+    }
+    onItemToggle(e) {
+        this.fireEvent("item-toggle", { item: e.detail.item });
+    }
+    onForwardBefore(e) {
+        this.setPreviouslyFocusedItem(e.target);
+        this.focusBeforeElement();
+        e.stopPropagation();
+    }
+    onForwardAfter(e) {
+        this.setPreviouslyFocusedItem(e.target);
+        if (!this.growsWithButton) {
+            this.focusAfterElement();
+        }
+        else {
+            this.focusGrowingButton();
+            e.preventDefault();
+        }
+        e.stopPropagation();
+    }
+    focusBeforeElement() {
+        this.setForwardingFocus(true);
+        this.getBeforeElement().focus();
+    }
+    focusAfterElement() {
+        this.setForwardingFocus(true);
+        this.getAfterElement().focus();
+    }
+    focusGrowingButton() {
+        const growingBtn = this.getGrowingButton();
+        if (growingBtn) {
+            growingBtn.focus();
+        }
+    }
+    getGrowingButton() {
+        return this.shadowRoot.querySelector(`[id="${this._id}-growing-btn"]`);
+    }
+    /**
+     * Focuses the first list item and sets its tabindex to "0" via the ItemNavigation
+     * @protected
+     */
+    focusFirstItem() {
+        // only enabled items are focusable
+        const firstItem = this.getFirstItem(x => x._focusable);
+        if (firstItem) {
+            firstItem.focus();
+        }
+    }
+    focusPreviouslyFocusedItem() {
+        const previouslyFocusedItem = this.getPreviouslyFocusedItem();
+        if (previouslyFocusedItem) {
+            previouslyFocusedItem.focus();
+        }
+    }
+    focusFirstSelectedItem() {
+        // only enabled items are focusable
+        const firstSelectedItem = this.getFirstItem(x => x.selected && x._focusable);
+        if (firstSelectedItem) {
+            firstSelectedItem.focus();
+        }
+    }
+    /**
+     * Focuses a list item and sets its tabindex to "0" via the ItemNavigation
+     * @protected
+     * @param item
+     */
+    focusItem(item) {
+        this._itemNavigation.setCurrentItem(item);
+        item.focus();
+    }
+    onFocusRequested(e) {
+        setTimeout(() => {
+            this.setPreviouslyFocusedItem(e.target);
+            this.focusPreviouslyFocusedItem();
+        }, 0);
+    }
+    setForwardingFocus(forwardingFocus) {
+        this._forwardingFocus = forwardingFocus;
+    }
+    getForwardingFocus() {
+        return this._forwardingFocus;
+    }
+    setPreviouslyFocusedItem(item) {
+        this._previouslyFocusedItem = item;
+    }
+    getPreviouslyFocusedItem() {
+        return this._previouslyFocusedItem;
+    }
+    getFirstItem(filter) {
+        const slottedItems = this.getItems();
+        let firstItem = null;
+        if (!filter) {
+            return slottedItems.length ? slottedItems[0] : null;
+        }
+        for (let i = 0; i < slottedItems.length; i++) {
+            if (filter(slottedItems[i])) {
+                firstItem = slottedItems[i];
+                break;
+            }
+        }
+        return firstItem;
+    }
+    getAfterElement() {
+        if (!this._afterElement) {
+            this._afterElement = this.shadowRoot.querySelector(`[id="${this._id}-after"]`);
+        }
+        return this._afterElement;
+    }
+    getBeforeElement() {
+        if (!this._beforeElement) {
+            this._beforeElement = this.shadowRoot.querySelector(`[id="${this._id}-before"]`);
+        }
+        return this._beforeElement;
+    }
+    getIntersectionObserver() {
+        if (!this.growingIntersectionObserver) {
+            this.growingIntersectionObserver = new IntersectionObserver(this.onInteresection.bind(this), {
+                root: null,
+                rootMargin: "0px",
+                threshold: 1.0,
+            });
+        }
+        return this.growingIntersectionObserver;
+    }
+};
+__decorate([
+    property()
+], List.prototype, "headerText", void 0);
+__decorate([
+    property()
+], List.prototype, "footerText", void 0);
+__decorate([
+    property({ type: Boolean })
+], List.prototype, "indent", void 0);
+__decorate([
+    property({ type: ListSelectionMode, defaultValue: ListSelectionMode.None })
+], List.prototype, "selectionMode", void 0);
+__decorate([
+    property()
+], List.prototype, "noDataText", void 0);
+__decorate([
+    property({ type: ListSeparators, defaultValue: ListSeparators.All })
+], List.prototype, "separators", void 0);
+__decorate([
+    property({ type: ListGrowingMode, defaultValue: ListGrowingMode.None })
+], List.prototype, "growing", void 0);
+__decorate([
+    property()
+], List.prototype, "growingButtonText", void 0);
+__decorate([
+    property({ type: Boolean })
+], List.prototype, "loading", void 0);
+__decorate([
+    property({ validator: Integer, defaultValue: 1000 })
+], List.prototype, "loadingDelay", void 0);
+__decorate([
+    property()
+], List.prototype, "accessibleName", void 0);
+__decorate([
+    property({ defaultValue: "" })
+], List.prototype, "accessibleNameRef", void 0);
+__decorate([
+    property({ type: ListAccessibleRole, defaultValue: ListAccessibleRole.List })
+], List.prototype, "accessibleRole", void 0);
+__decorate([
+    property({ type: Boolean })
+], List.prototype, "_inViewport", void 0);
+__decorate([
+    property({ type: Boolean })
+], List.prototype, "_loadMoreActive", void 0);
+__decorate([
+    slot({ type: HTMLElement, "default": true })
+], List.prototype, "items", void 0);
+__decorate([
+    slot()
+], List.prototype, "header", void 0);
+List = List_1 = __decorate([
+    customElement({
+        tag: "ui5-list",
+        fastNavigation: true,
+        renderer: litRender,
+        template: ListTemplate,
+        styles: [browserScrollbarCSS, listCss],
+        dependencies: [BusyIndicator, DropIndicator, ListItemGroup],
+    })
+    /**
+     * Fired when an item is activated, unless the item's `type` property
+     * is set to `Inactive`.
+     * @allowPreventDefault
+     * @param {HTMLElement} item The clicked item.
+     * @public
+     */
+    ,
+    event("item-click", {
+        detail: {
+            /**
+             * @public
+             */
+            item: { type: HTMLElement },
+        },
+    })
+    /**
+     * Fired when the `Close` button of any item is clicked
+     *
+     * **Note:** This event is only applicable to list items that can be closed (such as notification list items),
+     * not to be confused with `item-delete`.
+     * @param {HTMLElement} item the item about to be closed.
+     * @public
+     * @since 1.0.0-rc.8
+     */
+    ,
+    event("item-close", {
+        detail: {
+            /**
+             * @public
+             */
+            item: { type: HTMLElement },
+        },
+    })
+    /**
+     * Fired when the `Toggle` button of any item is clicked.
+     *
+     * **Note:** This event is only applicable to list items that can be toggled (such as notification group list items).
+     * @param {HTMLElement} item the toggled item.
+     * @public
+     * @since 1.0.0-rc.8
+     */
+    ,
+    event("item-toggle", {
+        detail: {
+            /**
+             * @public
+             */
+            item: { type: HTMLElement },
+        },
+    })
+    /**
+     * Fired when the Delete button of any item is pressed.
+     *
+     * **Note:** A Delete button is displayed on each item,
+     * when the component `selectionMode` property is set to `Delete`.
+     * @param {HTMLElement} item the deleted item.
+     * @public
+     */
+    ,
+    event("item-delete", {
+        detail: {
+            /**
+             * @public
+             */
+            item: { type: HTMLElement },
+        },
+    })
+    /**
+     * Fired when selection is changed by user interaction
+     * in `Single`, `SingleStart`, `SingleEnd` and `Multiple` selection modes.
+     * @allowPreventDefault
+     * @param {Array<ListItemBase>} selectedItems An array of the selected items.
+     * @param {Array<ListItemBase>} previouslySelectedItems An array of the previously selected items.
+     * @public
+     */
+    ,
+    event("selection-change", {
+        detail: {
+            /**
+             * @public
+             */
+            selectedItems: { type: Array },
+            /**
+             * @public
+             */
+            previouslySelectedItems: { type: Array },
+            /**
+             * protected, holds the event target item
+             * @protected
+             */
+            targetItem: { type: HTMLElement },
+            /**
+             * protected, indicates if the user used the selection components to change the selection
+             * @protected
+             */
+            selectionComponentPressed: { type: Boolean },
+            /**
+             * @private
+             */
+            key: { type: String },
+        },
+    })
+    /**
+     * Fired when the user scrolls to the bottom of the list.
+     *
+     * **Note:** The event is fired when the `growing='Scroll'` property is enabled.
+     * @public
+     * @since 1.0.0-rc.6
+     */
+    ,
+    event("load-more")
+    /**
+     * @private
+     */
+    ,
+    event("item-focused", {
+        detail: {
+            item: { type: HTMLElement },
+        },
+    })
+    /**
+     * Fired when a movable list 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()`.
+     * @param {object} source Contains information about the moved element under `element` property.
+     * @param {object} destination Contains information about the destination of the moved element. Has `element` and `placement` properties.
+     * @public
+     * @since 2.0.0
+     * @allowPreventDefault
+     */
+    ,
+    event("move-over", {
+        detail: {
+            /**
+             * @public
+             */
+            source: { type: Object },
+            /**
+             * @public
+             */
+            destination: { type: Object },
+        },
+    })
+    /**
+     * Fired when a movable list item is dropped onto a drop target.
+     *
+     * **Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.
+     * @param {object} source Contains information about the moved element under `element` property.
+     * @param {object} destination Contains information about the destination of the moved element. Has `element` and `placement` properties.
+     * @public
+     * @allowPreventDefault
+     */
+    ,
+    event("move", {
+        detail: {
+            /**
+             * @public
+             */
+            source: { type: Object },
+            /**
+             * @public
+             */
+            destination: { type: Object },
+        },
+    })
+], List);
 List.define();
-
 export default List;
+//# sourceMappingURL=List.js.map