@ui5/webcomponents 1.0.0-rc.8 → 1.0.2

package/dist/Popover.js

@@ -1,14 +1,17 @@
 import Integer from "@ui5/webcomponents-base/dist/types/Integer.js";
+import ResizeHandler from "@ui5/webcomponents-base/dist/delegate/ResizeHandler.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 { getClosedPopupParent } 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";
 
@@ -34,7 +37,7 @@ 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>
@@ -54,7 +57,7 @@ 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>
@@ -74,7 +77,7 @@ 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>
@@ -94,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.
 		 *
@@ -107,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}
@@ -129,6 +144,17 @@ const metadata = {
 			type: Boolean,
 		},
 
+		/**
+		 * Defines whether the content is scrollable.
+		 *
+		 * @type {boolean}
+		 * @defaultvalue false
+		 * @private
+		 */
+		disableScrolling: {
+			type: Boolean,
+		},
+
 		/**
 		 * Sets the X translation of the arrow
 		 *
@@ -161,7 +187,14 @@ const metadata = {
 			defaultValue: PopoverPlacementType.Right,
 		},
 
-		_maxContentHeight: { type: Integer },
+		_maxContentHeight: {
+			type: Integer,
+			noAttribute: true,
+		},
+		_maxContentWidth: {
+			type: Integer,
+			noAttribute: true,
+		},
 	},
 	managedSlots: true,
 	slots: /** @lends sap.ui.webcomponents.main.Popover.prototype */ {
@@ -228,41 +261,58 @@ const metadata = {
  * @public
  */
 class Popover extends Popup {
+	constructor() {
+		super();
+
+		this._handleResize = this.handleResize.bind(this);
+	}
+
 	static get metadata() {
 		return metadata;
 	}
 
 	static get styles() {
-		return [PopupsCommonCss, PopoverCss];
+		return [browserScrollbarCSS, PopupsCommonCss, PopoverCss];
 	}
 
 	static get template() {
 		return PopoverTemplate;
 	}
 
-	static get MIN_OFFSET() {
+	static get VIEWPORT_MARGIN() {
 		return 10; // px
 	}
 
+	onEnterDOM() {
+		ResizeHandler.register(this, this._handleResize);
+	}
+
+	onExitDOM() {
+		ResizeHandler.deregister(this, this._handleResize);
+	}
+
 	isOpenerClicked(event) {
 		const target = event.target;
-		return target === this._opener || (target.getFocusDomRef && target.getFocusDomRef() === this._opener);
+		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, preventInitialFocus = false) {
+	async showAt(opener, preventInitialFocus = false) {
 		if (!opener || this.opened) {
 			return;
 		}
 
 		this._opener = opener;
+		this._openerRect = opener.getBoundingClientRect();
 
-		super.open(preventInitialFocus);
+		await super._open(preventInitialFocus);
 	}
 
 	/**
@@ -294,7 +344,7 @@ class Popover extends Popup {
 		let overflowsBottom = false;
 		let overflowsTop = false;
 
-		if (closedPopupParent.openBy) {
+		if (closedPopupParent.showAt) {
 			const contentRect = closedPopupParent.contentDOM.getBoundingClientRect();
 			overflowsBottom = openerRect.top > (contentRect.top + contentRect.height);
 			overflowsTop = (openerRect.top + openerRect.height) < contentRect.top;
@@ -310,21 +360,36 @@ class Popover extends Popup {
 			&& openerRect.right === 0;
 	}
 
+	handleResize() {
+		if (this.opened) {
+			this.reposition();
+		}
+	}
+
 	reposition() {
-		this.show();
+		this._show();
 	}
 
-	show() {
+	_show() {
 		let placement;
-		const popoverSize = this.popoverSize;
-		const openerRect = this._opener.getBoundingClientRect();
+		const popoverSize = this.getPopoverSize();
 
-		if (this.shouldCloseDueToNoOpener(openerRect) && this.isFocusWithin()) {
+		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.isOpen()) {
+			// update opener rect if it was changed during the popover being opened
+			this._openerRect = this._opener.getBoundingClientRect();
+		}
+
+		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(openerRect, popoverSize);
+			placement = this.calcPlacement(this._openerRect, popoverSize);
 		}
 
 		const stretching = this.horizontalAlign === PopoverHorizontalAlign.Stretch;
@@ -333,52 +398,78 @@ class Popover extends Popup {
 			return this.close();
 		}
 
-		if (this._oldPlacement && (this._oldPlacement.left === placement.left) && (this._oldPlacement.top === placement.top) && stretching) {
-			super.show();
-			this.style.width = this._width;
-			return;
-		}
-
 		this._oldPlacement = placement;
-
-		const popoverOnLeftBorder = this._left === 0;
-		const popoverOnTopBorder = this._top === 0;
-
 		this.actualPlacementType = placement.placementType;
-		this.arrowTranslateX = popoverOnLeftBorder ? placement.arrowX - Popover.MIN_OFFSET : placement.arrowX;
-		this.arrowTranslateY = popoverOnTopBorder ? placement.arrowY - Popover.MIN_OFFSET : placement.arrowY;
 
-		this.style.left = `${popoverOnLeftBorder ? Popover.MIN_OFFSET : this._left}px`;
-		this.style.top = `${popoverOnTopBorder ? Popover.MIN_OFFSET : this._top}px`;
-		super.show();
+		let left = clamp(
+			this._left,
+			Popover.VIEWPORT_MARGIN,
+			document.documentElement.clientWidth - popoverSize.width - Popover.VIEWPORT_MARGIN,
+		);
 
-		if (stretching && this._width) {
-			this.style.width = this._width;
+		if (this.actualPlacementType === PopoverPlacementType.Right) {
+			left = Math.max(left, this._left);
 		}
-	}
 
-	get popoverSize() {
-		let width,
-			height;
-		let rect = this.getBoundingClientRect();
+		let top = clamp(
+			this._top,
+			Popover.VIEWPORT_MARGIN,
+			document.documentElement.clientHeight - popoverSize.height - Popover.VIEWPORT_MARGIN,
+		);
 
-		if (this.opened) {
-			width = rect.width;
-			height = rect.height;
+		if (this.actualPlacementType === PopoverPlacementType.Bottom) {
+			top = Math.max(top, this._top);
+		}
+
+		let { arrowX, arrowY } = placement;
+		const isVertical = this.actualPlacementType === PopoverPlacementType.Top
+			|| this.actualPlacementType === PopoverPlacementType.Bottom;
 
-			return { width, height };
+		if (isVertical) {
+			const popoverOnLeftBorderOffset = Popover.VIEWPORT_MARGIN - this._left;
+			const popoverOnRightBorderOffset = this._left + popoverSize.width + Popover.VIEWPORT_MARGIN - document.documentElement.clientWidth;
+			if (popoverOnLeftBorderOffset > 0) {
+				arrowX -= popoverOnLeftBorderOffset;
+			} else if (popoverOnRightBorderOffset > 0) {
+				arrowX += popoverOnRightBorderOffset;
+			}
+		}
+		this.arrowTranslateX = Math.round(arrowX);
+
+		if (!isVertical) {
+			const popoverOnTopBorderOffset = Popover.VIEWPORT_MARGIN - this._top;
+			const popoverOnBottomBorderOffset = this._top + popoverSize.height + Popover.VIEWPORT_MARGIN - document.documentElement.clientHeight;
+			if (popoverOnTopBorderOffset > 0) {
+				arrowY -= popoverOnTopBorderOffset;
+			} else if (popoverOnBottomBorderOffset > 0) {
+				arrowY += popoverOnBottomBorderOffset;
+			}
 		}
+		this.arrowTranslateY = Math.round(arrowY);
 
-		this.style.visibility = "hidden";
-		this.style.display = "block";
+		Object.assign(this.style, {
+			top: `${top}px`,
+			left: `${left}px`,
+		});
+		super._show();
 
-		rect = this.getBoundingClientRect();
+		if (stretching && this._width) {
+			this.style.width = this._width;
+		}
+	}
 
-		width = rect.width;
-		height = rect.height;
+	getPopoverSize() {
+		if (!this.opened) {
+			Object.assign(this.style, {
+				display: "block",
+				top: "-10000px",
+				left: "-10000px",
+			});
+		}
 
-		this.hide();
-		this.style.visibility = "visible";
+		const rect = this.getBoundingClientRect(),
+			width = rect.width,
+			height = rect.height;
 
 		return { width, height };
 	}
@@ -400,6 +491,7 @@ class Popover extends Popup {
 		const clientHeight = document.documentElement.clientHeight;
 
 		let maxHeight = clientHeight;
+		let maxWidth = clientWidth;
 
 		let width = "";
 		let height = "";
@@ -422,7 +514,7 @@ class Popover extends Popup {
 		this._width = width;
 		this._height = height;
 
-		const arrowOffset = this.noArrow ? 0 : arrowSize;
+		const arrowOffset = this.hideArrow ? 0 : arrowSize;
 
 		// calc popover positions
 		switch (placementType) {
@@ -447,12 +539,17 @@ class Popover extends Popup {
 		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:
 			if (allowTargetOverlap) {
 				left = Math.max(Math.min(targetRect.left + targetRect.width + arrowOffset, clientWidth - popoverSize.width), 0);
 			} else {
 				left = targetRect.left + targetRect.width + arrowOffset;
+				maxWidth = clientWidth - targetRect.right - arrowOffset;
 			}
 
 			top = this.getHorizontalTop(targetRect, popoverSize);
@@ -474,23 +571,21 @@ class Popover extends Popup {
 			}
 		}
 
-		let maxContentHeight = Math.round(maxHeight);
+		let maxContentHeight = maxHeight;
 
-		const hasHeader = this.header.length || this.headerText;
-
-		if (hasHeader) {
+		if (this._displayHeader) {
 			const headerDomRef = this.shadowRoot.querySelector(".ui5-popup-header-root")
 				|| this.shadowRoot.querySelector(".ui5-popup-header-text");
 
 			if (headerDomRef) {
-				maxContentHeight = Math.round(maxHeight - headerDomRef.offsetHeight);
+				maxContentHeight = maxHeight - headerDomRef.offsetHeight;
 			}
 		}
 
-		this._maxContentHeight = maxContentHeight;
+		this._maxContentHeight = Math.round(maxContentHeight - Popover.VIEWPORT_MARGIN);
+		this._maxContentWidth = Math.round(maxWidth - Popover.VIEWPORT_MARGIN);
 
-		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;
+		const arrowPos = this.getArrowPosition(targetRect, popoverSize, left, top, isVertical);
 
 		if (this._left === undefined || Math.abs(this._left - left) > 1.5) {
 			this._left = Math.round(left);
@@ -501,14 +596,51 @@ class Popover extends Popup {
 		}
 
 		return {
-			arrowX: Math.round(arrowTranslateX),
-			arrowY: Math.round(arrowTranslateY),
+			arrowX: arrowPos.x,
+			arrowY: arrowPos.y,
 			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
@@ -572,6 +704,7 @@ class Popover extends Popup {
 		switch (this.horizontalAlign) {
 		case PopoverHorizontalAlign.Center:
 		case PopoverHorizontalAlign.Stretch:
+
 			left = targetRect.left - (popoverSize.width - targetRect.width) / 2;
 			break;
 		case PopoverHorizontalAlign.Left:
@@ -608,8 +741,12 @@ class Popover extends Popup {
 		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";
+		return this.accessibleName ? undefined : "ui5-popup-header";
 	}
 
 	get _ariaModal() { // Required by Popup.js
@@ -621,6 +758,7 @@ class Popover extends Popup {
 			...super.styles,
 			content: {
 				"max-height": `${this._maxContentHeight}px`,
+				"max-width": `${this._maxContentWidth}px`,
 			},
 			arrow: {
 				transform: `translate(${this.arrowTranslateX}px, ${this.arrowTranslateY}px)`,
@@ -628,22 +766,11 @@ class Popover extends Popup {
 		};
 	}
 
-	get classes() {
-		return {
-			root: {
-				"ui5-popup-root": true,
-			},
-			content: {
-				"ui5-popup-content": true,
-			},
-		};
-	}
-
 	/**
 	 * Hook for descendants to hide header.
 	 */
 	get _displayHeader() {
-		return true;
+		return this.header.length || this.headerText;
 	}
 
 	/**