@ui5/webcomponents 0.0.0-389bdbabc → 0.0.0-38f83ffef

package/dist/Popover.js

@@ -1,691 +1,678 @@
-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 PopoverPlacementType from "./types/PopoverPlacementType.js";
+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 Popover_1;
+import { instanceOfUI5Element } from "@ui5/webcomponents-base/dist/UI5Element.js";
+import customElement from "@ui5/webcomponents-base/dist/decorators/customElement.js";
+import property from "@ui5/webcomponents-base/dist/decorators/property.js";
+import slot from "@ui5/webcomponents-base/dist/decorators/slot.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 getEffectiveScrollbarStyle from "@ui5/webcomponents-base/dist/util/getEffectiveScrollbarStyle.js";
+import DOMReferenceConverter from "@ui5/webcomponents-base/dist/converters/DOMReference.js";
+import { renderFinished } from "@ui5/webcomponents-base/dist/Render.js";
+import Popup from "./Popup.js";
+import PopoverPlacement from "./types/PopoverPlacement.js";
 import PopoverVerticalAlign from "./types/PopoverVerticalAlign.js";
 import PopoverHorizontalAlign from "./types/PopoverHorizontalAlign.js";
-
 import { addOpenedPopover, removeOpenedPopover } from "./popup-utils/PopoverRegistry.js";
-import { getFocusedElement, getClosedPopupParent } from "./popup-utils/PopupUtils.js";
-
+// Template
+import PopoverTemplate from "./PopoverTemplate.js";
 // Styles
+import PopupsCommonCss from "./generated/themes/PopupsCommon.css.js";
 import PopoverCss from "./generated/themes/Popover.css.js";
-
-const arrowSize = 8;
-
-/**
- * @public
- */
-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.
-		 *
-		 * @type {string}
-		 * @defaultvalue: ""
-		 * @public
-		 */
-		headerText: {
-			type: String,
-		},
-
-		/**
-		 * Determines on which side the <code>ui5-popover</code> is placed at.
-		 *
-		 * @type {PopoverPlacementType}
-		 * @defaultvalue "Right"
-		 * @public
-		 */
-		placementType: {
-			type: PopoverPlacementType,
-			defaultValue: PopoverPlacementType.Right,
-		},
-
-		/**
-		 * Determines the horizontal alignment of the <code>ui5-popover</code>.
-		 *
-		 * @type {PopoverHorizontalAlign}
-		 * @defaultvalue "Center"
-		 * @public
-		 */
-		horizontalAlign: {
-			type: PopoverHorizontalAlign,
-			defaultValue: PopoverHorizontalAlign.Center,
-		},
-
-		/**
-		 * Determines the vertical alignment of the <code>ui5-popover</code>.
-		 *
-		 * @type {PopoverVerticalAlign}
-		 * @defaultvalue "Center"
-		 * @public
-		 */
-		verticalAlign: {
-			type: PopoverVerticalAlign,
-			defaultValue: PopoverVerticalAlign.Center,
-		},
-
-		/**
-		 * Defines whether the <code>ui5-popover</code> should close when
-		 * clicking/tapping outside of the popover.
-		 * If enabled, it blocks any interaction with the background.
-		 *
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @public
-		 */
-		modal: {
-			type: Boolean,
-		},
-
-		/**
-		 * Determines whether the <code>ui5-popover</code> arrow is hidden.
-		 *
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @public
-		 */
-		noArrow: {
-			type: Boolean,
-		},
-
-		/**
-		 * Determines if there is no enough space, the <code>ui5-popover</code> can be placed
-		 * over the target.
-		 *
-		 * @type {boolean}
-		 * @defaultvalue false
-		 * @public
-		 */
-		allowTargetOverlap: {
-			type: Boolean,
-		},
-
-		/**
-		 * Sets the X translation of the arrow
-		 *
-		 * @private
-		 */
-		arrowTranslateX: {
-			type: Integer,
-			defaultValue: 0,
-			noAttribute: true,
-		},
-
-		/**
-		 * Sets the Y translation of the arrow
-		 *
-		 * @private
-		 */
-		arrowTranslateY: {
-			type: Integer,
-			defaultValue: 0,
-			noAttribute: true,
-		},
-
-		/**
-		 * Returns the calculated placement depending on the free space
-		 *
-		 * @private
-		 */
-		actualPlacementType: {
-			type: PopoverPlacementType,
-			defaultValue: PopoverPlacementType.Right,
-		},
-
-		/**
-		 * Defines whether the <code>ui5-popover</code> is open
-		 *
-		 * @private
-		 */
-		opened: { type: Boolean },
-
-		_maxContentHeight: { type: Integer },
-
-		/**
-		 * @private
-		 */
-		_disableInitialFocus: {
-			type: Boolean,
-		},
-	},
-	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.
-		 *
-		 * @type {HTMLElement[]}
-		 * @slot
-		 * @public
-		 */
-		header: {
-			type: HTMLElement,
-		},
-
-		/**
-		 * Defines the footer HTML Element.
-		 *
-		 * @type {HTMLElement[]}
-		 * @slot
-		 * @public
-		 */
-		footer: {
-			type: HTMLElement,
-		},
-	},
-	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: {},
-	},
-};
-
+const ARROW_SIZE = 8;
 /**
  * @class
  *
- * <h3 class="comment-api-title">Overview</h3>
+ * ### Overview
  *
- * The <code>ui5-popover</code> component displays additional information for an object
+ * The `ui5-popover` component displays additional information for an object
  * in a compact way and without leaving the page.
  * The Popover can contain various UI elements, such as fields, tables, images, and charts.
  * It can also include actions in the footer.
  *
- * <h3>Structure</h3>
+ * ### Structure
  *
  * The popover has three main areas:
- * <ul>
- * <li>Header (optional)</li>
- * <li>Content</li>
- * <li>Footer (optional)</li>
- * </ul>
  *
- * <b>Note:</b> The <code>ui5-popover</code> is closed when the user clicks
+ * - Header (optional)
+ * - Content
+ * - Footer (optional)
+ *
+ * **Note:** The `ui5-popover` is closed when the user clicks
  * or taps outside the popover
  * or selects an action within the popover. You can prevent this with the
- * <code>modal</code> property.
+ * `modal` property.
  *
- * <h3>ES6 Module Import</h3>
+ * ### ES6 Module Import
  *
- * <code>import "@ui5/webcomponents/dist/Popover.js";</code>
+ * `import "@ui5/webcomponents/dist/Popover.js";`
  *
  * @constructor
- * @author SAP SE
- * @alias sap.ui.webcomponents.main.Popover
- * @extends UI5Element
- * @tagname ui5-popover
+ * @extends Popup
+ * @since 1.0.0-rc.6
  * @public
+ * @csspart header - Used to style the header of the component
+ * @csspart content - Used to style the content of the component
+ * @csspart footer - Used to style the footer of the component
  */
-class Popover extends UI5Element {
-	static get metadata() {
-		return metadata;
-	}
-
-	static get render() {
-		return litRender;
-	}
-
-	static get styles() {
-		return PopoverCss;
-	}
-
-	static get template() {
-		return PopoverTemplate;
-	}
-
-	forwardToFirst() {
-		const firstFocusable = getFirstFocusableElement(this.contentDOM);
-
-		if (firstFocusable) {
-			firstFocusable.focus();
-		}
-	}
-
-	forwardToLast() {
-		const lastFocusable = getLastFocusableElement(this.contentDOM);
-
-		if (lastFocusable) {
-			lastFocusable.focus();
-		}
-	}
-
-	isOpenerClicked(event) {
-		return event.target === this._opener;
-	}
-
-	/**
-	 * Opens the popover.
-	 * @param {HTMLElement} opener the element that the popover is opened by
-	 * @public
-	 */
-	openBy(opener) {
-		if (!opener || this.opened) {
-			return;
-		}
-
-		this._opener = opener;
-		this._focusedElementBeforeOpen = getFocusedElement();
-
-		this.fireEvent("beforeOpen", {});
-		this.reposition();
-		this.applyInitialFocus();
-
-		addOpenedPopover(this);
-
-		this.opened = true;
-		this.fireEvent("afterOpen", {});
-	}
-
-	/**
-	 * Closes the popover.
-	 * @public
-	 */
-	close(escPressed = false, preventRegitryUpdate = false) {
-		if (!this.opened) {
-			return;
-		}
-
-		this.fireEvent("beforeClose", {
-			escPressed,
-		}, true);
-
-
-		this.opened = false;
-
-		if (!preventRegitryUpdate) {
-			removeOpenedPopover(this);
-		}
-
-		if (!this._prevetFocusRestore) {
-			this.resetFocus();
-		}
-
-		this.hide();
-		this.fireEvent("afterClose", {});
-	}
-
-	get focusedElement() {
-		let element = document.activeElement;
-
-		while (element.shadowRoot && element.shadowRoot.activeElement) {
-			element = element.shadowRoot.activeElement;
-		}
-
-		return (element && typeof element.focus === "function") ? element : null;
-	}
-
-	applyInitialFocus() {
-		if (this._disableInitialFocus) {
-			return;
-		}
-
-		const element = this.getRootNode().getElementById(this.initialFocus) || document.getElementById(this.initialFocus) || getFirstFocusableElement(this.contentDOM);
-
-		if (element) {
-			element.focus();
-		}
-	}
-
-	resetFocus() {
-		if (!this._focusedElementBeforeOpen) {
-			return;
-		}
-
-		this._focusedElementBeforeOpen.focus();
-		this._focusedElementBeforeOpen = null;
-	}
-
-	shouldCloseDueOverflow(placement, openerRect) {
-		const threshold = 32;
-
-		const limits = {
-			"Right": openerRect.top,
-			"Left": openerRect.top,
-			"Top": openerRect.top,
-			"Bottom": openerRect.top,
-		};
-
-		const closedPopupParent = getClosedPopupParent(this._opener);
-		let overflowsBottom = false;
-		let overflowsTop = false;
-
-		if (closedPopupParent.openBy) {
-			const contentRect = closedPopupParent.contentDOM.getBoundingClientRect();
-			overflowsBottom = openerRect.top > (contentRect.top + contentRect.height);
-			overflowsTop = (openerRect.top + openerRect.height) < contentRect.top;
-		}
-
-		return (limits[placement] < 0 || (limits[placement] + threshold > closedPopupParent.innerHeight)) || overflowsBottom || overflowsTop;
-	}
-
-	reposition() {
-		const popoverSize = this.popoverSize;
-		const openerRect = this._opener.getBoundingClientRect();
-		const placement = this.calcPlacement(openerRect, popoverSize);
-		const streching = this.horizontalAlign === PopoverHorizontalAlign.Stretch;
-
-		if (this._preventRepositionAndClose) {
-			return this.close();
-		}
-
-		if (this._oldPlacement && (this._oldPlacement.left === placement.left) && (this._oldPlacement.top === placement.top) && streching) {
-			this.style.display = "inline-block";
-			this.style.width = this._width;
-			return;
-		}
-
-		this._oldPlacement = placement;
-
-		this.actualPlacementType = placement.placementType;
-		this.arrowTranslateX = placement.arrowX;
-		this.arrowTranslateY = placement.arrowY;
-
-		this.style.left = `${this._left}px`;
-		this.style.top = `${this._top}px`;
-		this.style.display = "inline-block";
-
-		if (streching && this._width) {
-			this.style.width = this._width;
-		}
-	}
-
-	hide() {
-		this.style.display = "none";
-	}
-
-	get popoverSize() {
-		let width,
-			height;
-		let rect = this.getBoundingClientRect();
-
-		if (this.opened) {
-			width = rect.width;
-			height = rect.height;
-
-			return { width, height };
-		}
-
-		this.style.visibility = "hidden";
-		this.style.display = "inline-block";
-
-		rect = this.getBoundingClientRect();
-
-		width = rect.width;
-		height = rect.height;
-
-		this.style.display = "none";
-		this.style.visibility = "visible";
-
-		return { width, height };
-	}
-
-	get contentDOM() {
-		return this.shadowRoot.querySelector(".ui5-popover-content");
-	}
-
-	get arrowDOM() {
-		return this.shadowRoot.querySelector(".ui5-popover-arr");
-	}
-
-	calcPlacement(targetRect, popoverSize) {
-		let left = 0;
-		let top = 0;
-		const allowTargetOverlap = this.allowTargetOverlap;
-
-		const clientWidth = document.documentElement.clientWidth;
-		const clientHeight = document.documentElement.clientHeight;
-
-		let maxHeight = clientHeight;
-
-		let width = "";
-		let height = "";
-
-		const placementType = this.getActualPlacementType(targetRect, popoverSize);
-
-		this._preventRepositionAndClose = this.shouldCloseDueOverflow(placementType, targetRect);
-
-		const isVertical = placementType === PopoverPlacementType.Top
-			|| placementType === PopoverPlacementType.Bottom;
-
-		if (this.horizontalAlign === PopoverHorizontalAlign.Stretch && isVertical) {
-			popoverSize.width = targetRect.width;
-			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;
-
-		// calc popover positions
-		switch (placementType) {
-		case PopoverPlacementType.Top:
-			left = this.getVerticalLeft(targetRect, popoverSize);
-			top = Math.max(targetRect.top - popoverSize.height - arrowOffset, 0);
-
-			if (!allowTargetOverlap) {
-				maxHeight = targetRect.top - arrowOffset;
-			}
-			break;
-		case PopoverPlacementType.Bottom:
-			left = this.getVerticalLeft(targetRect, popoverSize);
-
-			if (allowTargetOverlap) {
-				top = Math.max(Math.min(targetRect.bottom + arrowOffset, 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);
-			break;
-		case PopoverPlacementType.Right:
-			if (allowTargetOverlap) {
-				left = Math.max(Math.min(targetRect.left + targetRect.width + arrowOffset, clientWidth - popoverSize.width), 0);
-			} else {
-				left = targetRect.left + targetRect.width + arrowOffset;
-			}
-
-			top = this.getHorizontalTop(targetRect, popoverSize);
-			break;
-		}
-
-		// correct popover positions
-		if (isVertical) {
-			if (popoverSize.width > clientWidth || left < 0) {
-				left = 0;
-			} else if (left + popoverSize.width > clientWidth) {
-				left -= left + popoverSize.width - clientWidth;
-			}
-		} else {
-			if (popoverSize.height > clientHeight || top < 0) { // eslint-disable-line
-				top = 0;
-			} else if (top + popoverSize.height > clientHeight) {
-				top -= top + popoverSize.height - clientHeight;
-			}
-		}
-
-		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;
-
-		if (this._left === undefined || Math.abs(this._left - left) > 1.5) {
-			this._left = Math.round(left);
-		}
-
-		if (this._top === undefined || Math.abs(this._top - top) > 1.5) {
-			this._top = Math.round(top);
-		}
-
-		return {
-			arrowX: Math.round(arrowTranslateX),
-			arrowY: Math.round(arrowTranslateY),
-			top: this._top,
-			left: this._left,
-			placementType,
-		};
-	}
-
-	getActualPlacementType(targetRect, popoverSize) {
-		const placementType = this.placementType;
-		let actualPlacementType = placementType;
-
-		const clientWidth = document.documentElement.clientWidth;
-		const clientHeight = document.documentElement.clientHeight;
-
-		switch (placementType) {
-		case PopoverPlacementType.Top:
-			if (targetRect.top < popoverSize.height
-				&& targetRect.top < clientHeight - targetRect.bottom) {
-				actualPlacementType = PopoverPlacementType.Bottom;
-			}
-			break;
-		case PopoverPlacementType.Bottom:
-			if (clientHeight - targetRect.bottom < popoverSize.height
-				&& clientHeight - targetRect.bottom < targetRect.top) {
-				actualPlacementType = PopoverPlacementType.Top;
-			}
-			break;
-		case PopoverPlacementType.Left:
-			if (targetRect.left < popoverSize.width
-				&& targetRect.left < clientWidth - targetRect.right) {
-				actualPlacementType = PopoverPlacementType.Right;
-			}
-			break;
-		case PopoverPlacementType.Right:
-			if (clientWidth - targetRect.right < popoverSize.width
-				&& clientWidth - targetRect.right < targetRect.left) {
-				actualPlacementType = PopoverPlacementType.Left;
-			}
-			break;
-		}
-
-		return actualPlacementType;
-	}
-
-	getVerticalLeft(targetRect, popoverSize) {
-		let left;
-
-		switch (this.horizontalAlign) {
-		case PopoverHorizontalAlign.Center:
-		case PopoverHorizontalAlign.Stretch:
-			left = targetRect.left - (popoverSize.width - targetRect.width) / 2;
-			break;
-		case PopoverHorizontalAlign.Left:
-			left = targetRect.left;
-			break;
-		case PopoverHorizontalAlign.Right:
-			left = targetRect.right - popoverSize.width;
-			break;
-		}
-
-		return left;
-	}
-
-	getHorizontalTop(targetRect, popoverSize) {
-		let top;
-
-		switch (this.verticalAlign) {
-		case PopoverVerticalAlign.Center:
-		case PopoverVerticalAlign.Stretch:
-			top = targetRect.top - (popoverSize.height - targetRect.height) / 2;
-			break;
-		case PopoverVerticalAlign.Top:
-			top = targetRect.top;
-			break;
-		case PopoverVerticalAlign.Bottom:
-			top = targetRect.bottom - popoverSize.height;
-			break;
-		}
-
-		return top;
-	}
-
-	get styles() {
-		return {
-			content: {
-				"max-height": `${this._maxContentHeight}px`,
-			},
-			arrow: {
-				transform: `translate(${this.arrowTranslateX}px, ${this.arrowTranslateY}px)`,
-			},
-		};
-	}
-}
-
+let Popover = Popover_1 = class Popover extends Popup {
+    static get VIEWPORT_MARGIN() {
+        return 10; // px
+    }
+    constructor() {
+        super();
+        /**
+         * Determines on which side the component is placed at.
+         * @default "End"
+         * @public
+         */
+        this.placement = "End";
+        /**
+         * Determines the horizontal alignment of the component.
+         * @default "Center"
+         * @public
+         */
+        this.horizontalAlign = "Center";
+        /**
+         * Determines the vertical alignment of the component.
+         * @default "Center"
+         * @public
+         */
+        this.verticalAlign = "Center";
+        /**
+         * Defines whether the component should close when
+         * clicking/tapping outside of the popover.
+         * If enabled, it blocks any interaction with the background.
+         * @default false
+         * @public
+         */
+        this.modal = false;
+        /**
+         * Determines whether the component arrow is hidden.
+         * @default false
+         * @public
+         * @since 1.0.0-rc.15
+         */
+        this.hideArrow = false;
+        /**
+         * Determines if there is no enough space, the component can be placed
+         * over the target.
+         * @default false
+         * @public
+         */
+        this.allowTargetOverlap = false;
+        /**
+         * Sets the X translation of the arrow
+         * @private
+         */
+        this.arrowTranslateX = 0;
+        /**
+         * Sets the Y translation of the arrow
+         * @private
+         */
+        this.arrowTranslateY = 0;
+        /**
+         * Returns the calculated placement depending on the free space
+         * @private
+         */
+        this.actualPlacement = "End";
+    }
+    /**
+     * Defines the ID or DOM Reference of the element at which the popover is shown.
+     * When using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.
+     * You can only set the `opener` attribute to a DOM Reference when using JavaScript.
+     * @public
+     * @default undefined
+     * @since 1.2.0
+     */
+    set opener(value) {
+        if (this._opener === value) {
+            return;
+        }
+        this._opener = value;
+        if (value && this.open) {
+            this.openPopup();
+        }
+    }
+    get opener() {
+        return this._opener;
+    }
+    async openPopup() {
+        if (this._opened) {
+            return;
+        }
+        const opener = this.getOpenerHTMLElement(this.opener);
+        if (!opener) {
+            return;
+        }
+        if (this.isOpenerOutsideViewport(opener.getBoundingClientRect())) {
+            await renderFinished();
+            this.open = false;
+            this.fireDecoratorEvent("close");
+            return;
+        }
+        this._openerRect = opener.getBoundingClientRect();
+        await super.openPopup();
+    }
+    isOpenerClicked(e) {
+        const target = e.target;
+        const opener = this.getOpenerHTMLElement(this.opener);
+        if (!opener) {
+            return false;
+        }
+        if (target === opener) {
+            return true;
+        }
+        if (this._isUI5AbstractElement(target) && target.getFocusDomRef() === opener) {
+            return true;
+        }
+        return e.composedPath().indexOf(opener) > -1;
+    }
+    /**
+     * Override for the _addOpenedPopup hook, which would otherwise just call addOpenedPopup(this)
+     * @private
+     */
+    _addOpenedPopup() {
+        addOpenedPopover(this);
+    }
+    /**
+     * Override for the _removeOpenedPopup hook, which would otherwise just call removeOpenedPopup(this)
+     * @private
+     */
+    _removeOpenedPopup() {
+        removeOpenedPopover(this);
+    }
+    getOpenerHTMLElement(opener) {
+        if (opener === undefined) {
+            return opener;
+        }
+        if (opener instanceof HTMLElement) {
+            return this._isUI5AbstractElement(opener) ? opener.getFocusDomRef() : opener;
+        }
+        let rootNode = this.getRootNode();
+        if (rootNode === this) {
+            rootNode = document;
+        }
+        let openerHTMLElement = rootNode.getElementById(opener);
+        if (rootNode instanceof ShadowRoot && !openerHTMLElement) {
+            openerHTMLElement = document.getElementById(opener);
+        }
+        if (openerHTMLElement) {
+            return this._isUI5AbstractElement(openerHTMLElement) ? openerHTMLElement.getFocusDomRef() : openerHTMLElement;
+        }
+        return openerHTMLElement;
+    }
+    shouldCloseDueToOverflow(placement, openerRect) {
+        const threshold = 32;
+        const limits = {
+            "Start": openerRect.right,
+            "End": openerRect.left,
+            "Top": openerRect.top,
+            "Bottom": openerRect.bottom,
+        };
+        const opener = this.getOpenerHTMLElement(this.opener);
+        const closedPopupParent = getClosedPopupParent(opener);
+        let overflowsBottom = false;
+        let overflowsTop = false;
+        if (closedPopupParent instanceof Popover_1) {
+            const contentRect = closedPopupParent.getBoundingClientRect();
+            overflowsBottom = openerRect.top > (contentRect.top + contentRect.height);
+            overflowsTop = (openerRect.top + openerRect.height) < contentRect.top;
+        }
+        return (limits[placement] < 0 || (limits[placement] + threshold > closedPopupParent.innerHeight)) || overflowsBottom || overflowsTop;
+    }
+    shouldCloseDueToNoOpener(openerRect) {
+        return openerRect.top === 0
+            && openerRect.bottom === 0
+            && openerRect.left === 0
+            && openerRect.right === 0;
+    }
+    isOpenerOutsideViewport(openerRect) {
+        return openerRect.bottom < 0
+            || openerRect.top > window.innerHeight
+            || openerRect.right < 0
+            || openerRect.left > window.innerWidth;
+    }
+    /**
+     * @override
+     */
+    _resize() {
+        super._resize();
+        if (this.open) {
+            this.reposition();
+        }
+    }
+    reposition() {
+        this._show();
+    }
+    async _show() {
+        super._show();
+        const opener = this.getOpenerHTMLElement(this.opener);
+        if (opener && instanceOfUI5Element(opener) && !opener.getDomRef()) {
+            return;
+        }
+        if (!this._opened) {
+            this._showOutsideViewport();
+        }
+        const popoverSize = this.getPopoverSize();
+        let placement;
+        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;
+        }
+        if (this.open) {
+            // update opener rect if it was changed during the popover being opened
+            this._openerRect = opener.getBoundingClientRect();
+        }
+        if (this._oldPlacement && 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);
+        }
+        if (this._preventRepositionAndClose || this.isOpenerOutsideViewport(this._openerRect)) {
+            await this._waitForDomRef();
+            return this.closePopup();
+        }
+        this._oldPlacement = placement;
+        this.actualPlacement = placement.placement;
+        let left = clamp(this._left, Popover_1.VIEWPORT_MARGIN, document.documentElement.clientWidth - popoverSize.width - Popover_1.VIEWPORT_MARGIN);
+        if (this.actualPlacement === PopoverPlacement.End) {
+            left = Math.max(left, this._left);
+        }
+        let top = clamp(this._top, Popover_1.VIEWPORT_MARGIN, document.documentElement.clientHeight - popoverSize.height - Popover_1.VIEWPORT_MARGIN);
+        if (this.actualPlacement === PopoverPlacement.Bottom) {
+            top = Math.max(top, this._top);
+        }
+        this.arrowTranslateX = placement.arrow.x;
+        this.arrowTranslateY = placement.arrow.y;
+        top = this._adjustForIOSKeyboard(top);
+        Object.assign(this.style, {
+            top: `${top}px`,
+            left: `${left}px`,
+        });
+        if (this.horizontalAlign === PopoverHorizontalAlign.Stretch && this._width) {
+            this.style.width = this._width;
+        }
+        if (this.verticalAlign === PopoverVerticalAlign.Stretch && this._height) {
+            this.style.height = this._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 top The target top in px.
+     * @returns The adjusted top in px.
+     */
+    _adjustForIOSKeyboard(top) {
+        if (!isIOS()) {
+            return top;
+        }
+        const actualTop = Math.ceil(this.getBoundingClientRect().top);
+        return top + (Number.parseInt(this.style.top || "0") - actualTop);
+    }
+    getPopoverSize() {
+        const rect = this.getBoundingClientRect(), width = rect.width, height = rect.height;
+        return { width, height };
+    }
+    _showOutsideViewport() {
+        Object.assign(this.style, {
+            top: "-10000px",
+            left: "-10000px",
+        });
+    }
+    _isUI5AbstractElement(el) {
+        return instanceOfUI5Element(el) && el.isUI5AbstractElement;
+    }
+    get arrowDOM() {
+        return this.shadowRoot.querySelector(".ui5-popover-arrow");
+    }
+    /**
+     * @protected
+     */
+    focusOpener() {
+        this.getOpenerHTMLElement(this.opener)?.focus();
+    }
+    /**
+     * @private
+     */
+    calcPlacement(targetRect, popoverSize) {
+        let left = Popover_1.VIEWPORT_MARGIN;
+        let top = 0;
+        const allowTargetOverlap = this.allowTargetOverlap;
+        const clientWidth = document.documentElement.clientWidth;
+        const clientHeight = document.documentElement.clientHeight;
+        let maxHeight = clientHeight;
+        let maxWidth = clientWidth;
+        const placement = this.getActualPlacement(targetRect, popoverSize);
+        this._preventRepositionAndClose = this.shouldCloseDueToNoOpener(targetRect) || this.shouldCloseDueToOverflow(placement, targetRect);
+        const isVertical = placement === PopoverPlacement.Top
+            || placement === PopoverPlacement.Bottom;
+        if (this.horizontalAlign === PopoverHorizontalAlign.Stretch && isVertical) {
+            popoverSize.width = targetRect.width;
+            this._width = `${targetRect.width}px`;
+        }
+        else if (this.verticalAlign === PopoverVerticalAlign.Stretch && !isVertical) {
+            popoverSize.height = targetRect.height;
+            this._height = `${targetRect.height}px`;
+        }
+        const arrowOffset = this.hideArrow ? 0 : ARROW_SIZE;
+        // calc popover positions
+        switch (placement) {
+            case PopoverPlacement.Top:
+                left = this.getVerticalLeft(targetRect, popoverSize);
+                top = Math.max(targetRect.top - popoverSize.height - arrowOffset, 0);
+                if (!allowTargetOverlap) {
+                    maxHeight = targetRect.top - arrowOffset;
+                }
+                break;
+            case PopoverPlacement.Bottom:
+                left = this.getVerticalLeft(targetRect, popoverSize);
+                top = targetRect.bottom + arrowOffset;
+                if (allowTargetOverlap) {
+                    top = Math.max(Math.min(top, clientHeight - popoverSize.height), 0);
+                }
+                else {
+                    maxHeight = clientHeight - targetRect.bottom - arrowOffset;
+                }
+                break;
+            case PopoverPlacement.Start:
+                left = Math.max(targetRect.left - popoverSize.width - arrowOffset, 0);
+                top = this.getHorizontalTop(targetRect, popoverSize);
+                if (!allowTargetOverlap) {
+                    maxWidth = targetRect.left - arrowOffset;
+                }
+                break;
+            case PopoverPlacement.End:
+                left = targetRect.left + targetRect.width + arrowOffset;
+                top = this.getHorizontalTop(targetRect, popoverSize);
+                if (allowTargetOverlap) {
+                    left = Math.max(Math.min(left, clientWidth - popoverSize.width), 0);
+                }
+                else {
+                    maxWidth = clientWidth - targetRect.right - arrowOffset;
+                }
+                break;
+        }
+        // correct popover positions
+        if (isVertical) {
+            if (popoverSize.width > clientWidth || left < Popover_1.VIEWPORT_MARGIN) {
+                left = Popover_1.VIEWPORT_MARGIN;
+            }
+            else if (left + popoverSize.width > clientWidth - Popover_1.VIEWPORT_MARGIN) {
+                left = clientWidth - Popover_1.VIEWPORT_MARGIN - popoverSize.width;
+            }
+        }
+        else {
+            if (popoverSize.height > clientHeight || top < Popover_1.VIEWPORT_MARGIN) { // eslint-disable-line
+                top = Popover_1.VIEWPORT_MARGIN;
+            }
+            else if (top + popoverSize.height > clientHeight - Popover_1.VIEWPORT_MARGIN) {
+                top = clientHeight - Popover_1.VIEWPORT_MARGIN - popoverSize.height;
+            }
+        }
+        this._maxHeight = Math.round(maxHeight - Popover_1.VIEWPORT_MARGIN);
+        this._maxWidth = Math.round(maxWidth - Popover_1.VIEWPORT_MARGIN);
+        if (this._left === undefined || Math.abs(this._left - left) > 1.5) {
+            this._left = Math.round(left);
+        }
+        if (this._top === undefined || Math.abs(this._top - top) > 1.5) {
+            this._top = Math.round(top);
+        }
+        const borderRadius = Number.parseInt(window.getComputedStyle(this).getPropertyValue("border-radius"));
+        const arrowPos = this.getArrowPosition(targetRect, popoverSize, left, top, isVertical, borderRadius);
+        this._left += this.getRTLCorrectionLeft();
+        return {
+            arrow: arrowPos,
+            top: this._top,
+            left: this._left,
+            placement,
+        };
+    }
+    getRTLCorrectionLeft() {
+        return parseFloat(window.getComputedStyle(this).left) - this.getBoundingClientRect().left;
+    }
+    /**
+     * 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
+     * @param borderRadius Value of the border-radius property
+     * @returns  Arrow's coordinates
+     */
+    getArrowPosition(targetRect, popoverSize, left, top, isVertical, borderRadius) {
+        const horizontalAlign = this._actualHorizontalAlign;
+        let arrowXCentered = horizontalAlign === PopoverHorizontalAlign.Center || horizontalAlign === PopoverHorizontalAlign.Stretch;
+        if (horizontalAlign === PopoverHorizontalAlign.End && left <= targetRect.left) {
+            arrowXCentered = true;
+        }
+        if (horizontalAlign === PopoverHorizontalAlign.Start && 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;
+        }
+        // Restricts the arrow's translate value along each dimension,
+        // so that the arrow does not clip over the popover's rounded borders.
+        const safeRangeForArrowY = popoverSize.height / 2 - borderRadius - ARROW_SIZE / 2 - 2;
+        arrowTranslateY = clamp(arrowTranslateY, -safeRangeForArrowY, safeRangeForArrowY);
+        const safeRangeForArrowX = popoverSize.width / 2 - borderRadius - ARROW_SIZE / 2 - 2;
+        arrowTranslateX = clamp(arrowTranslateX, -safeRangeForArrowX, safeRangeForArrowX);
+        return {
+            x: Math.round(arrowTranslateX),
+            y: Math.round(arrowTranslateY),
+        };
+    }
+    /**
+     * Fallbacks to new placement, prioritizing `Left` and `Right` placements.
+     * @private
+     */
+    fallbackPlacement(clientWidth, clientHeight, targetRect, popoverSize) {
+        if (targetRect.left > popoverSize.width) {
+            return PopoverPlacement.Start;
+        }
+        if (clientWidth - targetRect.right > targetRect.left) {
+            return PopoverPlacement.End;
+        }
+        if (clientHeight - targetRect.bottom > popoverSize.height) {
+            return PopoverPlacement.Bottom;
+        }
+        if (clientHeight - targetRect.bottom < targetRect.top) {
+            return PopoverPlacement.Top;
+        }
+    }
+    getActualPlacement(targetRect, popoverSize) {
+        const placement = this.placement;
+        let actualPlacement = placement;
+        const clientWidth = document.documentElement.clientWidth;
+        const clientHeight = document.documentElement.clientHeight;
+        switch (placement) {
+            case PopoverPlacement.Top:
+                if (targetRect.top < popoverSize.height
+                    && targetRect.top < clientHeight - targetRect.bottom) {
+                    actualPlacement = PopoverPlacement.Bottom;
+                }
+                break;
+            case PopoverPlacement.Bottom:
+                if (clientHeight - targetRect.bottom < popoverSize.height
+                    && clientHeight - targetRect.bottom < targetRect.top) {
+                    actualPlacement = PopoverPlacement.Top;
+                }
+                break;
+            case PopoverPlacement.Start:
+                if (targetRect.left < popoverSize.width) {
+                    actualPlacement = this.fallbackPlacement(clientWidth, clientHeight, targetRect, popoverSize) || placement;
+                }
+                break;
+            case PopoverPlacement.End:
+                if (clientWidth - targetRect.right < popoverSize.width) {
+                    actualPlacement = this.fallbackPlacement(clientWidth, clientHeight, targetRect, popoverSize) || placement;
+                }
+                break;
+        }
+        return actualPlacement;
+    }
+    getVerticalLeft(targetRect, popoverSize) {
+        const horizontalAlign = this._actualHorizontalAlign;
+        let left = Popover_1.VIEWPORT_MARGIN;
+        switch (horizontalAlign) {
+            case PopoverHorizontalAlign.Center:
+            case PopoverHorizontalAlign.Stretch:
+                left = targetRect.left - (popoverSize.width - targetRect.width) / 2;
+                break;
+            case PopoverHorizontalAlign.Start:
+                left = targetRect.left;
+                break;
+            case PopoverHorizontalAlign.End:
+                left = targetRect.right - popoverSize.width;
+                break;
+        }
+        return left;
+    }
+    getHorizontalTop(targetRect, popoverSize) {
+        let top = 0;
+        switch (this.verticalAlign) {
+            case PopoverVerticalAlign.Center:
+            case PopoverVerticalAlign.Stretch:
+                top = targetRect.top - (popoverSize.height - targetRect.height) / 2;
+                break;
+            case PopoverVerticalAlign.Top:
+                top = targetRect.top;
+                break;
+            case PopoverVerticalAlign.Bottom:
+                top = targetRect.bottom - popoverSize.height;
+                break;
+        }
+        return top;
+    }
+    get isModal() {
+        return this.modal;
+    }
+    get _ariaLabelledBy() {
+        if (!this._ariaLabel && this._displayHeader) {
+            return "ui5-popup-header";
+        }
+        return undefined;
+    }
+    get styles() {
+        return {
+            ...super.styles,
+            root: {
+                "max-height": this._maxHeight ? `${this._maxHeight}px` : "",
+                "max-width": this._maxWidth ? `${this._maxWidth}px` : "",
+            },
+            arrow: {
+                transform: `translate(${this.arrowTranslateX}px, ${this.arrowTranslateY}px)`,
+            },
+        };
+    }
+    get classes() {
+        const allClasses = super.classes;
+        allClasses.root["ui5-popover-root"] = true;
+        return allClasses;
+    }
+    /**
+     * Hook for descendants to hide header.
+     */
+    get _displayHeader() {
+        return !!(this.header.length || this.headerText);
+    }
+    /**
+     * Hook for descendants to hide footer.
+     */
+    get _displayFooter() {
+        return true;
+    }
+    get _actualHorizontalAlign() {
+        if (this.effectiveDir === "rtl") {
+            if (this.horizontalAlign === PopoverHorizontalAlign.Start) {
+                return PopoverHorizontalAlign.End;
+            }
+            if (this.horizontalAlign === PopoverHorizontalAlign.End) {
+                return PopoverHorizontalAlign.Start;
+            }
+        }
+        return this.horizontalAlign;
+    }
+};
+__decorate([
+    property()
+], Popover.prototype, "headerText", void 0);
+__decorate([
+    property()
+], Popover.prototype, "placement", void 0);
+__decorate([
+    property()
+], Popover.prototype, "horizontalAlign", void 0);
+__decorate([
+    property()
+], Popover.prototype, "verticalAlign", void 0);
+__decorate([
+    property({ type: Boolean })
+], Popover.prototype, "modal", void 0);
+__decorate([
+    property({ type: Boolean })
+], Popover.prototype, "hideArrow", void 0);
+__decorate([
+    property({ type: Boolean })
+], Popover.prototype, "allowTargetOverlap", void 0);
+__decorate([
+    property({ type: Number, noAttribute: true })
+], Popover.prototype, "arrowTranslateX", void 0);
+__decorate([
+    property({ type: Number, noAttribute: true })
+], Popover.prototype, "arrowTranslateY", void 0);
+__decorate([
+    property()
+], Popover.prototype, "actualPlacement", void 0);
+__decorate([
+    property({ type: Number, noAttribute: true })
+], Popover.prototype, "_maxHeight", void 0);
+__decorate([
+    property({ type: Number, noAttribute: true })
+], Popover.prototype, "_maxWidth", void 0);
+__decorate([
+    slot({ type: HTMLElement })
+], Popover.prototype, "header", void 0);
+__decorate([
+    slot({ type: HTMLElement })
+], Popover.prototype, "footer", void 0);
+__decorate([
+    property({ converter: DOMReferenceConverter })
+], Popover.prototype, "opener", null);
+Popover = Popover_1 = __decorate([
+    customElement({
+        tag: "ui5-popover",
+        styles: [
+            Popup.styles,
+            PopupsCommonCss,
+            PopoverCss,
+            getEffectiveScrollbarStyle(),
+        ],
+        template: PopoverTemplate,
+    })
+], Popover);
+const instanceOfPopover = (object) => {
+    return "opener" in object;
+};
 Popover.define();
-
 export default Popover;
+export { instanceOfPopover };
+//# sourceMappingURL=Popover.js.map