@ui5/webcomponents 0.0.0-32b659ddc → 0.0.0-35e2c9666

package/dist/Popover.js

@@ -1,16 +1,18 @@
-import UI5Element from "@ui5/webcomponents-base/dist/UI5Element.js";
-import litRender from "@ui5/webcomponents-base/dist/renderer/LitRenderer.js";
-import { getFirstFocusableElement, getLastFocusableElement } from "@ui5/webcomponents-base/dist/util/FocusableElements.js";
 import Integer from "@ui5/webcomponents-base/dist/types/Integer.js";
-import PopoverTemplate from "./generated/templates/PopoverTemplate.lit.js";
+import { isIOS } from "@ui5/webcomponents-base/dist/Device.js";
+import { getClosedPopupParent } from "@ui5/webcomponents-base/dist/util/PopupUtils.js";
+import clamp from "@ui5/webcomponents-base/dist/util/clamp.js";
+import Popup from "./Popup.js";
 import PopoverPlacementType from "./types/PopoverPlacementType.js";
 import PopoverVerticalAlign from "./types/PopoverVerticalAlign.js";
 import PopoverHorizontalAlign from "./types/PopoverHorizontalAlign.js";
-
 import { addOpenedPopover, removeOpenedPopover } from "./popup-utils/PopoverRegistry.js";
-import { getFocusedElement, getClosedPopupParent, getNextZIndex } from "./popup-utils/PopupUtils.js";
 
+// Template
+import PopoverTemplate from "./generated/templates/PopoverTemplate.lit.js";
 // Styles
+import browserScrollbarCSS from "./generated/themes/BrowserScrollbar.css.js";
+import PopupsCommonCss from "./generated/themes/PopupsCommon.css.js";
 import PopoverCss from "./generated/themes/Popover.css.js";
 
 const arrowSize = 8;
@@ -21,23 +23,13 @@ const arrowSize = 8;
 const metadata = {
 	tag: "ui5-popover",
 	properties: /** @lends sap.ui.webcomponents.main.Popover.prototype */ {
-		/**
-		 * Defines the ID of the HTML Element, which will get the initial focus.
-		 *
-		 * @type {string}
-		 * @defaultvalue: ""
-		 * @public
-		 */
-		initialFocus: {
-			type: String,
-		},
-
 		/**
 		 * Defines the header text.
-		 * <br><b>Note:</b> If <code>header</code> slot is provided, the <code>headerText</code> is ignored.
+		 * <br><br>
+		 * <b>Note:</b> If <code>header</code> slot is provided, the <code>headerText</code> is ignored.
 		 *
 		 * @type {string}
-		 * @defaultvalue: ""
+		 * @defaultvalue ""
 		 * @public
 		 */
 		headerText: {
@@ -45,7 +37,15 @@ const metadata = {
 		},
 
 		/**
-		 * Determines on which side the <code>ui5-popover</code> is placed at.
+		 * Determines on which side the component is placed at.
+		 * <br><br>
+		 * Available options are:
+		 * <ul>
+		 * <li><code>Left</code></li>
+		 * <li><code>Right</code></li>
+		 * <li><code>Top</code></li>
+		 * <li><code>Bottom</code></li>
+		 * </ul>
 		 *
 		 * @type {PopoverPlacementType}
 		 * @defaultvalue "Right"
@@ -57,7 +57,15 @@ const metadata = {
 		},
 
 		/**
-		 * Determines the horizontal alignment of the <code>ui5-popover</code>.
+		 * Determines the horizontal alignment of the component.
+		 * <br><br>
+		 * Available options are:
+		 * <ul>
+		 * <li><code>Center</code></li>
+		 * <li><code>Left</code></li>
+		 * <li><code>Right</code></li>
+		 * <li><code>Stretch</code></li>
+		 * </ul>
 		 *
 		 * @type {PopoverHorizontalAlign}
 		 * @defaultvalue "Center"
@@ -69,7 +77,15 @@ const metadata = {
 		},
 
 		/**
-		 * Determines the vertical alignment of the <code>ui5-popover</code>.
+		 * Determines the vertical alignment of the component.
+		 * <br><br>
+		 * Available options are:
+		 * <ul>
+		 * <li><code>Center</code></li>
+		 * <li><code>Top</code></li>
+		 * <li><code>Bottom</code></li>
+		 * <li><code>Stretch</code></li>
+		 * </ul>
 		 *
 		 * @type {PopoverVerticalAlign}
 		 * @defaultvalue "Center"
@@ -81,7 +97,7 @@ const metadata = {
 		},
 
 		/**
-		 * Defines whether the <code>ui5-popover</code> should close when
+		 * Defines whether the component should close when
 		 * clicking/tapping outside of the popover.
 		 * If enabled, it blocks any interaction with the background.
 		 *
@@ -94,18 +110,30 @@ const metadata = {
 		},
 
 		/**
-		 * Determines whether the <code>ui5-popover</code> arrow is hidden.
+		 * Defines whether the block layer will be shown if modal property is set to true.
+		 * @type {boolean}
+		 * @defaultvalue false
+		 * @public
+		 * @since 1.0.0-rc.10
+		 */
+		hideBackdrop: {
+			type: Boolean,
+		},
+
+		/**
+		 * Determines whether the component arrow is hidden.
 		 *
 		 * @type {boolean}
 		 * @defaultvalue false
 		 * @public
+		 * @since 1.0.0-rc.15
 		 */
-		noArrow: {
+		hideArrow: {
 			type: Boolean,
 		},
 
 		/**
-		 * Determines if there is no enough space, the <code>ui5-popover</code> can be placed
+		 * Determines if there is no enough space, the component can be placed
 		 * over the target.
 		 *
 		 * @type {boolean}
@@ -116,6 +144,28 @@ const metadata = {
 			type: Boolean,
 		},
 
+		/**
+		 * Defines the opener id of the element that the popover is shown at
+		 * @public
+		 * @type {String}
+		 * @defaultvalue ""
+		 * @since 1.2.0
+		 */
+		opener: {
+			type: String,
+		},
+
+		/**
+		 * Defines whether the content is scrollable.
+		 *
+		 * @type {boolean}
+		 * @defaultvalue false
+		 * @private
+		 */
+		disableScrolling: {
+			type: Boolean,
+		},
+
 		/**
 		 * Sets the X translation of the arrow
 		 *
@@ -148,34 +198,17 @@ const metadata = {
 			defaultValue: PopoverPlacementType.Right,
 		},
 
-		/**
-		 * Defines whether the <code>ui5-popover</code> is open
-		 *
-		 * @private
-		 */
-		opened: { type: Boolean },
-
-		_maxContentHeight: { type: Integer },
-
-		/**
-		 * @private
-		 */
-		_disableInitialFocus: {
-			type: Boolean,
+		_maxHeight: {
+			type: Integer,
+			noAttribute: true,
+		},
+		_maxWidth: {
+			type: Integer,
+			noAttribute: true,
 		},
 	},
 	managedSlots: true,
 	slots: /** @lends sap.ui.webcomponents.main.Popover.prototype */ {
-		/**
-		 * Defines the content of the Web Component.
-		 * @type {Node[]}
-		 * @slot
-		 * @public
-		 */
-		"default": {
-			type: Node,
-		},
-
 		/**
 		 * Defines the header HTML Element.
 		 *
@@ -199,40 +232,6 @@ const metadata = {
 		},
 	},
 	events: /** @lends sap.ui.webcomponents.main.Popover.prototype */ {
-		/**
-		 * Fired before the component is opened.
-		 *
-		 * @public
-		 * @event
-		 */
-		beforeOpen: {},
-
-		/**
-		 * Fired after the component is opened.
-		 *
-		 * @public
-		 * @event
-		 */
-		afterOpen: {},
-
-		/**
-		 * Fired before the component is closed.
-		 *
-		 * @public
-		 * @event
-		 * @param {Boolean} escPressed Indicates that <code>ESC</code> key has triggered the event.
-		 */
-		beforeClose: {
-			escPressed: { type: Boolean },
-		},
-
-		/**
-		 * Fired after the component is closed.
-		 *
-		 * @public
-		 * @event
-		 */
-		afterClose: {},
 	},
 };
 
@@ -260,6 +259,17 @@ const metadata = {
  * or selects an action within the popover. You can prevent this with the
  * <code>modal</code> property.
  *
+ * <h3>CSS Shadow Parts</h3>
+ *
+ * <ui5-link target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/CSS/::part">CSS Shadow Parts</ui5-link> allow developers to style elements inside the Shadow DOM.
+ * <br>
+ * The <code>ui5-popover</code> exposes the following CSS Shadow Parts:
+ * <ul>
+ * <li>header - Used to style the header of the component</li>
+ * <li>content - Used to style the content of the component</li>
+ * <li>footer - Used to style the footer of the component</li>
+ * </ul>
+ *
  * <h3>ES6 Module Import</h3>
  *
  * <code>import "@ui5/webcomponents/dist/Popover.js";</code>
@@ -267,223 +277,309 @@ const metadata = {
  * @constructor
  * @author SAP SE
  * @alias sap.ui.webcomponents.main.Popover
- * @extends UI5Element
+ * @extends Popup
  * @tagname ui5-popover
  * @since 1.0.0-rc.6
  * @public
  */
-class Popover extends UI5Element {
-	static get metadata() {
-		return metadata;
+class Popover extends Popup {
+	constructor() {
+		super();
 	}
 
-	static get render() {
-		return litRender;
+	static get metadata() {
+		return metadata;
 	}
 
 	static get styles() {
-		return PopoverCss;
+		return [browserScrollbarCSS, PopupsCommonCss, PopoverCss];
 	}
 
 	static get template() {
 		return PopoverTemplate;
 	}
 
-	forwardToFirst() {
-		const firstFocusable = getFirstFocusableElement(this.contentDOM);
+	static get VIEWPORT_MARGIN() {
+		return 10; // px
+	}
 
-		if (firstFocusable) {
-			firstFocusable.focus();
-		}
+	static get ARROW_MARGIN() {
+		return 6; // px
 	}
 
-	forwardToLast() {
-		const lastFocusable = getLastFocusableElement(this.contentDOM);
+	onAfterRendering() {
+		if (!this.isOpen() && this.open) {
+			const opener = document.getElementById(this.opener);
+			if (!opener) {
+				console.warn("Valid opener id is required."); // eslint-disable-line
+				return;
+			}
 
-		if (lastFocusable) {
-			lastFocusable.focus();
+			this.showAt(opener);
+		} else if (this.isOpen() && !this.open) {
+			this.close();
 		}
 	}
 
 	isOpenerClicked(event) {
-		return event.target === this._opener;
+		const target = event.target;
+		return target === this._opener || (target.getFocusDomRef && target.getFocusDomRef() === this._opener) || event.composedPath().indexOf(this._opener) > -1;
 	}
 
 	/**
-	 * Opens the popover.
-	 * @param {HTMLElement} opener the element that the popover is opened by
+	 * Shows the popover.
+	 * @param {HTMLElement} opener the element that the popover is shown at
+	 * @param {boolean} preventInitialFocus prevents applying the focus inside the popover
 	 * @public
+	 * @async
+	 * @returns {Promise} Resolved when the popover is open
 	 */
-	openBy(opener) {
+	async showAt(opener, preventInitialFocus = false) {
 		if (!opener || this.opened) {
 			return;
 		}
 
 		this._opener = opener;
-		this._focusedElementBeforeOpen = getFocusedElement();
-		this.style.zIndex = getNextZIndex();
+		this._openerRect = opener.getBoundingClientRect();
 
-		this.fireEvent("beforeOpen", {});
-		this.reposition();
-		this.applyInitialFocus();
+		await super._open(preventInitialFocus);
+	}
 
+	/**
+	 * Override for the _addOpenedPopup hook, which would otherwise just call addOpenedPopup(this)
+	 * @private
+	 */
+	_addOpenedPopup() {
 		addOpenedPopover(this);
-
-		this.opened = true;
-		this.fireEvent("afterOpen", {});
 	}
 
 	/**
-	 * Closes the popover.
-	 * @public
+	 * Override for the _removeOpenedPopup hook, which would otherwise just call removeOpenedPopup(this)
+	 * @private
 	 */
-	close(escPressed = false, preventRegitryUpdate = false) {
-		if (!this.opened) {
-			return;
-		}
-
-		this.fireEvent("beforeClose", {
-			escPressed,
-		}, true);
+	_removeOpenedPopup() {
+		removeOpenedPopover(this);
+	}
 
+	shouldCloseDueToOverflow(placement, openerRect) {
+		const threshold = 32;
+		const limits = {
+			"Right": openerRect.right,
+			"Left": openerRect.left,
+			"Top": openerRect.top,
+			"Bottom": openerRect.bottom,
+		};
 
-		this.opened = false;
+		const closedPopupParent = getClosedPopupParent(this._opener);
+		let overflowsBottom = false;
+		let overflowsTop = false;
 
-		if (!preventRegitryUpdate) {
-			removeOpenedPopover(this);
+		if (closedPopupParent.showAt) {
+			const contentRect = closedPopupParent.contentDOM.getBoundingClientRect();
+			overflowsBottom = openerRect.top > (contentRect.top + contentRect.height);
+			overflowsTop = (openerRect.top + openerRect.height) < contentRect.top;
 		}
 
-		if (!this._prevetFocusRestore) {
-			this.resetFocus();
-		}
+		return (limits[placement] < 0 || (limits[placement] + threshold > closedPopupParent.innerHeight)) || overflowsBottom || overflowsTop;
+	}
 
-		this.hide();
-		this.fireEvent("afterClose", {});
+	shouldCloseDueToNoOpener(openerRect) {
+		return openerRect.top === 0
+			&& openerRect.bottom === 0
+			&& openerRect.left === 0
+			&& openerRect.right === 0;
 	}
 
-	get focusedElement() {
-		let element = document.activeElement;
+	isOpenerOutsideViewport(openerRect) {
+		return openerRect.bottom < 0
+			|| openerRect.top > window.innerHeight
+			|| openerRect.right < 0
+			|| openerRect.left > window.innerWidth;
+	}
 
-		while (element.shadowRoot && element.shadowRoot.activeElement) {
-			element = element.shadowRoot.activeElement;
+	/**
+	 * @override
+	 */
+	_resize() {
+		super._resize();
+
+		if (this.opened) {
+			this.reposition();
 		}
+	}
 
-		return (element && typeof element.focus === "function") ? element : null;
+	reposition() {
+		this._show();
 	}
 
-	applyInitialFocus() {
-		if (this._disableInitialFocus) {
+	_show() {
+		let placement;
+		const popoverSize = this.getPopoverSize();
+
+		if (popoverSize.width === 0 || popoverSize.height === 0) {
+			// size can not be determined properly at this point, popover will be shown with the next reposition
 			return;
 		}
 
-		const element = this.getRootNode().getElementById(this.initialFocus) || document.getElementById(this.initialFocus) || getFirstFocusableElement(this.contentDOM);
+		if (this.isOpen()) {
+			// update opener rect if it was changed during the popover being opened
+			this._openerRect = this._opener.getBoundingClientRect();
+		}
 
-		if (element) {
-			element.focus();
+		if (this.shouldCloseDueToNoOpener(this._openerRect) && this.isFocusWithin()) {
+			// reuse the old placement as the opener is not available,
+			// but keep the popover open as the focus is within
+			placement = this._oldPlacement;
+		} else {
+			placement = this.calcPlacement(this._openerRect, popoverSize);
 		}
-	}
 
-	resetFocus() {
-		if (!this._focusedElementBeforeOpen) {
-			return;
+		const stretching = this.horizontalAlign === PopoverHorizontalAlign.Stretch;
+
+		if (this._preventRepositionAndClose || this.isOpenerOutsideViewport(this._openerRect)) {
+			return this.close();
 		}
 
-		this._focusedElementBeforeOpen.focus();
-		this._focusedElementBeforeOpen = null;
-	}
+		this._oldPlacement = placement;
+		this.actualPlacementType = placement.placementType;
 
-	shouldCloseDueOverflow(placement, openerRect) {
-		const threshold = 32;
+		let left = clamp(
+			this._left,
+			Popover.VIEWPORT_MARGIN,
+			document.documentElement.clientWidth - popoverSize.width - Popover.VIEWPORT_MARGIN,
+		);
 
-		const limits = {
-			"Right": openerRect.top,
-			"Left": openerRect.top,
-			"Top": openerRect.top,
-			"Bottom": openerRect.top,
-		};
+		if (this.actualPlacementType === PopoverPlacementType.Right) {
+			left = Math.max(left, this._left);
+		}
 
-		const closedPopupParent = getClosedPopupParent(this._opener);
-		let overflowsBottom = false;
-		let overflowsTop = false;
+		let top = clamp(
+			this._top,
+			Popover.VIEWPORT_MARGIN,
+			document.documentElement.clientHeight - popoverSize.height - Popover.VIEWPORT_MARGIN,
+		);
 
-		if (closedPopupParent.openBy) {
-			const contentRect = closedPopupParent.contentDOM.getBoundingClientRect();
-			overflowsBottom = openerRect.top > (contentRect.top + contentRect.height);
-			overflowsTop = (openerRect.top + openerRect.height) < contentRect.top;
+		if (this.actualPlacementType === PopoverPlacementType.Bottom) {
+			top = Math.max(top, this._top);
 		}
 
-		return (limits[placement] < 0 || (limits[placement] + threshold > closedPopupParent.innerHeight)) || overflowsBottom || overflowsTop;
-	}
+		const isVertical = this.actualPlacementType === PopoverPlacementType.Top || this.actualPlacementType === PopoverPlacementType.Bottom;
+		const borderRadius = Number.parseInt(window.getComputedStyle(this).getPropertyValue("border-radius"));
+		const arrow = this._clampArrowPlacement(placement.arrow, isVertical, this._top, this._left, popoverSize, borderRadius);
 
-	reposition() {
-		const popoverSize = this.popoverSize;
-		const openerRect = this._opener.getBoundingClientRect();
-		const placement = this.calcPlacement(openerRect, popoverSize);
-		const streching = this.horizontalAlign === PopoverHorizontalAlign.Stretch;
+		this.arrowTranslateX = arrow.x;
+		this.arrowTranslateY = arrow.y;
 
-		if (this._preventRepositionAndClose) {
-			return this.close();
-		}
+		top = this._adjustForIOSKeyboard(top);
+
+		Object.assign(this.style, {
+			top: `${top}px`,
+			left: `${left}px`,
+		});
+		super._show();
 
-		if (this._oldPlacement && (this._oldPlacement.left === placement.left) && (this._oldPlacement.top === placement.top) && streching) {
-			this.style.display = "inline-block";
+		if (stretching && this._width) {
 			this.style.width = this._width;
-			return;
 		}
+	}
 
-		this._oldPlacement = placement;
+	/**
+	 * Restricts the arrow's coordinates within the bounds of the popover.
+	 * @private
+	 * @param {{x: number, y: number}} arrow arrow's coordinates
+	 * @param {boolean} isVertical if the popover is placed vertically relative to the opener
+	 * @param {number} top popover's top
+	 * @param {number} left popover's left
+	 * @param {{width: number, height: number}} popoverSize popover's width and height
+	 * @param {number} borderRadius value of the border-radius property
+	 * @returns {{x: number, y: number}} Arrow's coordinates
+	 */
+	_clampArrowPlacement({ x, y }, isVertical, top, left, { width, height }, borderRadius) {
+		const maxY = this._getArrowRange(height, borderRadius);
+		const maxX = this._getArrowRange(width, borderRadius);
 
-		this.actualPlacementType = placement.placementType;
-		this.arrowTranslateX = placement.arrowX;
-		this.arrowTranslateY = placement.arrowY;
+		if (isVertical) {
+			const popoverOnLeftBorderOffset = Popover.VIEWPORT_MARGIN - left;
+			const popoverOnRightBorderOffset = left + width + Popover.VIEWPORT_MARGIN - document.documentElement.clientWidth;
 
-		this.style.left = `${this._left}px`;
-		this.style.top = `${this._top}px`;
-		this.style.display = "inline-block";
+			if (popoverOnLeftBorderOffset > 0) {
+				x = Math.max(x - popoverOnLeftBorderOffset, -maxX);
+			} else if (popoverOnRightBorderOffset > 0) {
+				x = Math.min(x + popoverOnRightBorderOffset, maxX);
+			}
+		}
 
-		if (streching && this._width) {
-			this.style.width = this._width;
+		if (!isVertical) {
+			const popoverOnTopBorderOffset = Popover.VIEWPORT_MARGIN - top;
+			const popoverOnBottomBorderOffset = top + height + Popover.VIEWPORT_MARGIN - document.documentElement.clientHeight;
+			if (popoverOnTopBorderOffset > 0) {
+				y = Math.max(y - popoverOnTopBorderOffset, -maxY);
+			} else if (popoverOnBottomBorderOffset > 0) {
+				y = Math.min(y + popoverOnBottomBorderOffset, maxY);
+			}
 		}
-	}
 
-	hide() {
-		this.style.display = "none";
+		return {
+			x: Math.round(x),
+			y: Math.round(y),
+		};
 	}
 
-	get popoverSize() {
-		let width,
-			height;
-		let rect = this.getBoundingClientRect();
-
-		if (this.opened) {
-			width = rect.width;
-			height = rect.height;
+	/**
+	 * Returns the allowed range for the popover arrow based on its dimension.
+	 * @private
+	 * @param {number} dimension the height or width of the popover
+	 * @param {number} borderRadius border radius of the popover
+	 * @returns {number}
+	 */
+	_getArrowRange(dimension, borderRadius) {
+		return Math.floor((dimension / 2) - (borderRadius + Popover.ARROW_MARGIN));
+	}
 
-			return { width, height };
+	/**
+	 * Adjust the desired top position to compensate for shift of the screen
+	 * caused by opened keyboard on iOS which affects all elements with position:fixed.
+	 * @private
+	 * @param {int} top The target top in px.
+	 * @returns {int} The adjusted top in px.
+	 */
+	_adjustForIOSKeyboard(top) {
+		if (!isIOS()) {
+			return top;
 		}
 
-		this.style.visibility = "hidden";
-		this.style.display = "inline-block";
+		const actualTop = Math.ceil(this.getBoundingClientRect().top);
 
-		rect = this.getBoundingClientRect();
+		return top + (Number.parseInt(this.style.top || "0") - actualTop);
+	}
 
-		width = rect.width;
-		height = rect.height;
+	getPopoverSize() {
+		if (!this.opened) {
+			Object.assign(this.style, {
+				display: "block",
+				top: "-10000px",
+				left: "-10000px",
+			});
+		}
 
-		this.style.display = "none";
-		this.style.visibility = "visible";
+		const rect = this.getBoundingClientRect(),
+			width = rect.width,
+			height = rect.height;
 
 		return { width, height };
 	}
 
 	get contentDOM() {
-		return this.shadowRoot.querySelector(".ui5-popover-content");
+		return this.shadowRoot.querySelector(".ui5-popup-content");
 	}
 
 	get arrowDOM() {
-		return this.shadowRoot.querySelector(".ui5-popover-arr");
+		return this.shadowRoot.querySelector(".ui5-popover-arrow");
 	}
 
+	/**
+	 * @private
+	 */
 	calcPlacement(targetRect, popoverSize) {
 		let left = 0;
 		let top = 0;
@@ -493,29 +589,23 @@ class Popover extends UI5Element {
 		const clientHeight = document.documentElement.clientHeight;
 
 		let maxHeight = clientHeight;
-
-		let width = "";
-		let height = "";
+		let maxWidth = clientWidth;
 
 		const placementType = this.getActualPlacementType(targetRect, popoverSize);
 
-		this._preventRepositionAndClose = this.shouldCloseDueOverflow(placementType, targetRect);
+		this._preventRepositionAndClose = this.shouldCloseDueToNoOpener(targetRect) || this.shouldCloseDueToOverflow(placementType, targetRect);
 
 		const isVertical = placementType === PopoverPlacementType.Top
 			|| placementType === PopoverPlacementType.Bottom;
 
 		if (this.horizontalAlign === PopoverHorizontalAlign.Stretch && isVertical) {
 			popoverSize.width = targetRect.width;
-			width = `${targetRect.width}px`;
+			this._width = `${targetRect.width}px`;
 		} else if (this.verticalAlign === PopoverVerticalAlign.Stretch && !isVertical) {
 			popoverSize.height = targetRect.height;
-			height = `${targetRect.height}px`;
 		}
 
-		this._width = width;
-		this._height = height;
-
-		const arrowOffset = this.noArrow ? 0 : arrowSize;
+		const arrowOffset = this.hideArrow ? 0 : arrowSize;
 
 		// calc popover positions
 		switch (placementType) {
@@ -529,26 +619,31 @@ class Popover extends UI5Element {
 			break;
 		case PopoverPlacementType.Bottom:
 			left = this.getVerticalLeft(targetRect, popoverSize);
+			top = targetRect.bottom + arrowOffset;
 
 			if (allowTargetOverlap) {
-				top = Math.max(Math.min(targetRect.bottom + arrowOffset, clientHeight - popoverSize.height), 0);
+				top = Math.max(Math.min(top, clientHeight - popoverSize.height), 0);
 			} else {
-				top = targetRect.bottom + arrowOffset;
 				maxHeight = clientHeight - targetRect.bottom - arrowOffset;
 			}
 			break;
 		case PopoverPlacementType.Left:
 			left = Math.max(targetRect.left - popoverSize.width - arrowOffset, 0);
 			top = this.getHorizontalTop(targetRect, popoverSize);
+
+			if (!allowTargetOverlap) {
+				maxWidth = targetRect.left - arrowOffset;
+			}
 			break;
 		case PopoverPlacementType.Right:
+			left = targetRect.left + targetRect.width + arrowOffset;
+			top = this.getHorizontalTop(targetRect, popoverSize);
+
 			if (allowTargetOverlap) {
-				left = Math.max(Math.min(targetRect.left + targetRect.width + arrowOffset, clientWidth - popoverSize.width), 0);
+				left = Math.max(Math.min(left, clientWidth - popoverSize.width), 0);
 			} else {
-				left = targetRect.left + targetRect.width + arrowOffset;
+				maxWidth = clientWidth - targetRect.right - arrowOffset;
 			}
-
-			top = this.getHorizontalTop(targetRect, popoverSize);
 			break;
 		}
 
@@ -567,23 +662,8 @@ class Popover extends UI5Element {
 			}
 		}
 
-		let maxContentHeight = Math.round(maxHeight);
-
-		const hasHeader = this.header.length || this.headerText;
-
-		if (hasHeader) {
-			const headerDomRef = this.shadowRoot.querySelector(".ui5-popover-header-root")
-				|| this.shadowRoot.querySelector(".ui5-popup-header-text");
-
-			if (headerDomRef) {
-				maxContentHeight = Math.round(maxHeight - headerDomRef.offsetHeight);
-			}
-		}
-
-		this._maxContentHeight = maxContentHeight;
-
-		const arrowTranslateX = isVertical ? targetRect.left + targetRect.width / 2 - left - popoverSize.width / 2 : 0;
-		const arrowTranslateY = !isVertical ? targetRect.top + targetRect.height / 2 - top - popoverSize.height / 2 : 0;
+		this._maxHeight = Math.round(maxHeight - Popover.VIEWPORT_MARGIN);
+		this._maxWidth = Math.round(maxWidth - Popover.VIEWPORT_MARGIN);
 
 		if (this._left === undefined || Math.abs(this._left - left) > 1.5) {
 			this._left = Math.round(left);
@@ -593,15 +673,75 @@ class Popover extends UI5Element {
 			this._top = Math.round(top);
 		}
 
+		const arrowPos = this.getArrowPosition(targetRect, popoverSize, left, top, isVertical);
+
 		return {
-			arrowX: Math.round(arrowTranslateX),
-			arrowY: Math.round(arrowTranslateY),
+			arrow: arrowPos,
 			top: this._top,
 			left: this._left,
 			placementType,
 		};
 	}
 
+	/**
+	 * Calculates the position for the arrow.
+	 * @private
+	 * @param targetRect BoundingClientRect of the target element
+	 * @param popoverSize Width and height of the popover
+	 * @param left Left offset of the popover
+	 * @param top Top offset of the popover
+	 * @param isVertical if the popover is positioned vertically to the target element
+	 * @returns {{x: number, y: number}} Arrow's coordinates
+	 */
+	getArrowPosition(targetRect, popoverSize, left, top, isVertical) {
+		let arrowXCentered = this.horizontalAlign === PopoverHorizontalAlign.Center || this.horizontalAlign === PopoverHorizontalAlign.Stretch;
+
+		if (this.horizontalAlign === PopoverHorizontalAlign.Right && left <= targetRect.left) {
+			arrowXCentered = true;
+		}
+
+		if (this.horizontalAlign === PopoverHorizontalAlign.Left && left + popoverSize.width >= targetRect.left + targetRect.width) {
+			arrowXCentered = true;
+		}
+
+		let arrowTranslateX = 0;
+		if (isVertical && arrowXCentered) {
+			arrowTranslateX = targetRect.left + targetRect.width / 2 - left - popoverSize.width / 2;
+		}
+
+		let arrowTranslateY = 0;
+		if (!isVertical) {
+			arrowTranslateY = targetRect.top + targetRect.height / 2 - top - popoverSize.height / 2;
+		}
+
+		return {
+			x: Math.round(arrowTranslateX),
+			y: Math.round(arrowTranslateY),
+		};
+	}
+
+	/**
+	 * Fallbacks to new placement, prioritizing <code>Left</code> and <code>Right</code> placements.
+	 * @private
+	 */
+	fallbackPlacement(clientWidth, clientHeight, targetRect, popoverSize) {
+		if (targetRect.left > popoverSize.width) {
+			return PopoverPlacementType.Left;
+		}
+
+		if (clientWidth - targetRect.right > targetRect.left) {
+			return PopoverPlacementType.Right;
+		}
+
+		if (clientHeight - targetRect.bottom > popoverSize.height) {
+			return PopoverPlacementType.Bottom;
+		}
+
+		if (clientHeight - targetRect.bottom < targetRect.top) {
+			return PopoverPlacementType.Top;
+		}
+	}
+
 	getActualPlacementType(targetRect, popoverSize) {
 		const placementType = this.placementType;
 		let actualPlacementType = placementType;
@@ -623,15 +763,13 @@ class Popover extends UI5Element {
 			}
 			break;
 		case PopoverPlacementType.Left:
-			if (targetRect.left < popoverSize.width
-				&& targetRect.left < clientWidth - targetRect.right) {
-				actualPlacementType = PopoverPlacementType.Right;
+			if (targetRect.left < popoverSize.width) {
+				actualPlacementType = this.fallbackPlacement(clientWidth, clientHeight, targetRect, popoverSize) || placementType;
 			}
 			break;
 		case PopoverPlacementType.Right:
-			if (clientWidth - targetRect.right < popoverSize.width
-				&& clientWidth - targetRect.right < targetRect.left) {
-				actualPlacementType = PopoverPlacementType.Left;
+			if (clientWidth - targetRect.right < popoverSize.width) {
+				actualPlacementType = this.fallbackPlacement(clientWidth, clientHeight, targetRect, popoverSize) || placementType;
 			}
 			break;
 		}
@@ -645,6 +783,7 @@ class Popover extends UI5Element {
 		switch (this.horizontalAlign) {
 		case PopoverHorizontalAlign.Center:
 		case PopoverHorizontalAlign.Stretch:
+
 			left = targetRect.left - (popoverSize.width - targetRect.width) / 2;
 			break;
 		case PopoverHorizontalAlign.Left:
@@ -677,23 +816,47 @@ class Popover extends UI5Element {
 		return top;
 	}
 
+	get isModal() { // Required by Popup.js
+		return this.modal;
+	}
+
+	get shouldHideBackdrop() { // Required by Popup.js
+		return this.hideBackdrop;
+	}
+
+	get _ariaLabelledBy() { // Required by Popup.js
+		return this._ariaLabel ? undefined : "ui5-popup-header";
+	}
+
+	get _ariaModal() { // Required by Popup.js
+		return true;
+	}
+
 	get styles() {
 		return {
-			content: {
-				"max-height": `${this._maxContentHeight}px`,
+			...super.styles,
+			root: {
+				"max-height": `${this._maxHeight}px`,
+				"max-width": `${this._maxWidth}px`,
 			},
 			arrow: {
 				transform: `translate(${this.arrowTranslateX}px, ${this.arrowTranslateY}px)`,
 			},
-			root: { },
 		};
 	}
 
+	get classes() {
+		const allClasses = super.classes;
+		allClasses.root["ui5-popover-root"] = true;
+
+		return allClasses;
+	}
+
 	/**
 	 * Hook for descendants to hide header.
 	 */
 	get _displayHeader() {
-		return true;
+		return this.header.length || this.headerText;
 	}
 
 	/**