@ui5/webcomponents 0.0.0-e463d2345 → 0.0.0-e55c2cec6

package/dist/Popup.js

@@ -1,461 +1,459 @@
+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 Popup_1;
+import { renderFinished } from "@ui5/webcomponents-base/dist/Render.js";
+import event from "@ui5/webcomponents-base/dist/decorators/event.js";
+import slot from "@ui5/webcomponents-base/dist/decorators/slot.js";
+import property from "@ui5/webcomponents-base/dist/decorators/property.js";
+import litRender from "@ui5/webcomponents-base/dist/renderer/LitRenderer.js";
 import UI5Element from "@ui5/webcomponents-base/dist/UI5Element.js";
+import { isChrome } from "@ui5/webcomponents-base/dist/Device.js";
 import { getFirstFocusableElement, getLastFocusableElement } from "@ui5/webcomponents-base/dist/util/FocusableElements.js";
-import Integer from "@ui5/webcomponents-base/dist/types/Integer.js";
-import { isEscape } from "@ui5/webcomponents-base/dist/events/PseudoEvents.js";
-
+import { getEffectiveAriaLabelText } from "@ui5/webcomponents-base/dist/util/AriaLabelHelper.js";
+import getEffectiveScrollbarStyle from "@ui5/webcomponents-base/dist/util/getEffectiveScrollbarStyle.js";
+import { hasStyle, createStyle } from "@ui5/webcomponents-base/dist/ManagedStyles.js";
+import { isEnter, isTabPrevious } from "@ui5/webcomponents-base/dist/Keys.js";
+import { getNextZIndex, getFocusedElement, isFocusedElementWithinNode } from "@ui5/webcomponents-base/dist/util/PopupUtils.js";
+import ResizeHandler from "@ui5/webcomponents-base/dist/delegate/ResizeHandler.js";
+import MediaRange from "@ui5/webcomponents-base/dist/MediaRange.js";
+import PopupTemplate from "./generated/templates/PopupTemplate.lit.js";
+import PopupBlockLayer from "./generated/templates/PopupBlockLayerTemplate.lit.js";
+import { addOpenedPopup, removeOpenedPopup } from "./popup-utils/OpenedPopupsRegistry.js";
 // Styles
 import styles from "./generated/themes/Popup.css.js";
-
-import { addOpenedPopup, removeOpenedPopup } from "./popup-utils/OpenedPopupsRegistry.js";
-
-/**
- * @public
- */
-const metadata = {
-	slots: /** @lends  sap.ui.webcomponents.main.Popup.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,
-		},
-	},
-	properties: /** @lends  sap.ui.webcomponents.main.Popup.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,
-		},
-
-		/**
-		 * Indicates if the elements is on focus
-		 * @private
-		 */
-		opened: {
-			type: Boolean,
-		},
-
-		_zIndex: {
-			type: Integer,
-			noAttribute: true,
-		},
-		_hideBlockLayer: {
-			type: Boolean,
-			noAttribute: true,
-		},
-	},
-	events: /** @lends  sap.ui.webcomponents.main.Popup.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: {},
-	},
+import staticAreaStyles from "./generated/themes/PopupStaticAreaStyles.css.js";
+import globalStyles from "./generated/themes/PopupGlobal.css.js";
+const createBlockingStyle = () => {
+    if (!hasStyle("data-ui5-popup-scroll-blocker")) {
+        createStyle(globalStyles, "data-ui5-popup-scroll-blocker");
+    }
 };
-
-const openedPopups = [];
-let currentZIndex = 100;
-let isBodyScrollingDisabled = false;
-let customBLyBackStyleInserted = false;
-
-function getParentHost(node) {
-	while (node && !node.host) {
-		node = node.parentNode;
-	}
-
-	return node && node.host;
-}
-
-function createBLyBackStyle() {
-	if (customBLyBackStyleInserted) {
-		return;
-	}
-
-	customBLyBackStyleInserted = true;
-
-	const bodyStyleSheet = document.createElement("style");
-	bodyStyleSheet.type = "text/css";
-	bodyStyleSheet.innerHTML = `
-		.ui5-popup-BLy--back {
-			width: 100%;
-			height: 100%;
-			position: fixed;
-			overflow: hidden;
-		}
-	`;
-	document.head.appendChild(bodyStyleSheet);
-}
-
-function updateBlockLayers() {
-	let popup,
-		i,
-		hasModal = false;
-
-	for (i = openedPopups.length - 1; i >= 0; i--) {
-		popup = openedPopups[i];
-		if (hasModal) {
-			popup._hideBlockLayer = true;
-		} else {
-			if (popup.isModal()) { // eslint-disable-line
-				popup._hideBlockLayer = false;
-				hasModal = true;
-			}
-		}
-	}
-
-	updateBodyScrolling(hasModal);
-}
-
-function updateBodyScrolling(hasModal) {
-	if (isBodyScrollingDisabled === hasModal) {
-		return;
-	}
-
-	createBLyBackStyle();
-
-	if (hasModal) {
-		addBodyStyles();
-	} else {
-		removeBodyStyles();
-	}
-	isBodyScrollingDisabled = hasModal;
-}
-
-function addBodyStyles() {
-	document.body.style.top = `-${window.pageYOffset}px`;
-	document.body.classList.add("ui5-popup-BLy--back");
-}
-
-function removeBodyStyles() {
-	document.body.classList.remove("ui5-popup-BLy--back");
-	window.scrollTo(0, -parseFloat(document.body.style.top));
-	document.body.style.top = "";
-}
-
+createBlockingStyle();
+const pageScrollingBlockers = new Set();
 /**
  * @class
  * <h3 class="comment-api-title">Overview</h3>
- * Represents a base class for all popup Web Components.
+ * Base class for all popup Web Components.
+ *
+ * If you need to create your own popup-like custom UI5 Web Components, it is highly recommended that you extend
+ * at least Popup in order to have consistency with other popups in terms of modal behavior and z-index management.
+ *
+ * 1. The Popup class handles modality:
+ *  - The "isModal" getter can be overridden by derivatives to provide their own conditions when they are modal or not
+ *  - Derivatives may call the "blockPageScrolling" and "unblockPageScrolling" static methods to temporarily remove scrollbars on the html element
+ *  - Derivatives may call the "open" and "close" methods which handle focus, manage the popup registry and for modal popups, manage the blocking layer
+ *
+ *  2. Provides blocking layer (relevant for modal popups only):
+ *   - It is in the static area
+ *   - Controlled by the "open" and "close" methods
+ *
+ * 3. The Popup class "traps" focus:
+ *  - Derivatives may call the "applyInitialFocus" method (usually when opening, to transfer focus inside the popup)
+ *
+ * 4. The Popup class automatically assigns "z-index"
+ *  - Each time a popup is opened, it gets a higher than the previously opened popup z-index
+ *
+ * 5. The template of this component exposes two inline partials you can override in derivatives:
+ *  - beforeContent (upper part of the box, useful for header/title/close button)
+ *  - afterContent (lower part, useful for footer/action buttons)
  *
  * @constructor
  * @author SAP SE
- * @alias sap.ui.webcomponents.main.Popup
- * @extends sap.ui.webcomponents.base.UI5Element
+ * @alias sap.ui.webc.main.Popup
+ * @extends sap.ui.webc.base.UI5Element
+ * @public
+ */
+/**
+ * Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening. <b>This event does not bubble.</b>
+ *
  * @public
+ * @event sap.ui.webc.main.Popup#before-open
+ * @allowPreventDefault
  */
-class Popup extends UI5Element {
-	static get metadata() {
-		return metadata;
-	}
-
-	static get styles() {
-		return styles;
-	}
-
-	static getNextZIndex() {
-		currentZIndex += 2;
-		return currentZIndex;
-	}
-
-	static hitTest(popup, event) {
-		const indexOf = openedPopups.indexOf(popup);
-		let openedPopup;
-
-		for (let i = indexOf; i < openedPopups.length; i++) {
-			openedPopup = openedPopups[i];
-			if (openedPopup.hitTest(event)) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	static hasModalPopup() {
-		for (let i = 0; i < openedPopups.length; i++) {
-			if (openedPopups[i].isModal()) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	constructor() {
-		super();
-
-		this._documentKeyDownHandler = this.documentKeyDown.bind(this);
-	}
-
-	isTopPopup() {
-		return openedPopups.indexOf(this) === openedPopups.length - 1;
-	}
-
-	isModal() {
-		return true;
-	}
-
-	documentKeyDown(event) {
-		if (isEscape(event) && this.isTopPopup()) {
-			this.escPressed = true;
-			this.close();
-		}
-	}
-
-	getPopupDomRef() {
-		const domRef = this.getDomRef();
-		return domRef && domRef.querySelector(".ui5-popup-root");
-	}
-
-	hitTest(_event) {
-		return true;
-	}
-
-	open() {
-		this.fireEvent("beforeOpen", { });
-
-		this._isFirstTimeRendered = false;
-
-		this._zIndex = Popup.getNextZIndex();
-		openedPopups.push(this);
-		addOpenedPopup(this);
-
-
-		updateBlockLayers();
-	}
-
-	close() {
-		this.fireEvent("beforeClose", {
-			escPressed: this.escPressed,
-		}, true);
-
-		this.escPressed = false;
-
-		const index = openedPopups.indexOf(this);
-		openedPopups.splice(index, 1);
-
-		if (this.opened) {
-			removeOpenedPopup(this);
-		}
-
-		updateBlockLayers();
-	}
-
-	initInitialFocus() {
-		const initialFocus = this.initialFocus;
-		let initialFocusDomRef = this.initialFocus;
-
-		if (initialFocus && typeof initialFocus === "string") {
-			initialFocusDomRef = document.getElementById(initialFocus);
-
-			if (!initialFocusDomRef) {
-				const parentHost = getParentHost(this);
-				if (parentHost) {
-					initialFocusDomRef = parentHost.shadowRoot.querySelector(`#${initialFocus}`);
-				}
-			}
-		}
-
-		this._initialFocusDomRef = initialFocusDomRef;
-	}
-
-	onFirstTimeAfterRendering() {
-		if (this.isTopPopup()) {
-			this.initInitialFocus();
-			this.setInitialFocus(this.getPopupDomRef());
-		}
-
-		this.fireEvent("afterOpen", {});
-	}
-
-	onAfterRendering() {
-		if (!this.opened) {
-			return;
-		}
-
-		if (!this._isFirstTimeRendered) {
-			this.onFirstTimeAfterRendering();
-			this._isFirstTimeRendered = true;
-		}
-	}
-
-	setInitialFocus(container) {
-		if (this._initialFocusDomRef) {
-			if (this._initialFocusDomRef !== document.activeElement) {
-				this._initialFocusDomRef.focus();
-			}
-			return;
-		}
-
-		if (!container) {
-			return;
-		}
-
-		const focusableElement = getFirstFocusableElement(container);
-
-		if (focusableElement) {
-			focusableElement.focus();
-		} else {
-			container.focus();
-		}
-	}
-
-	onfocusin(event) {
-		this.preserveFocus(event, this.getPopupDomRef());
-	}
-
-	preserveFocus(event, container) {
-		if (!this.isTopPopup()) {
-			return;
-		}
-
-		let target = event.target;
-
-		while (target.shadowRoot && target.shadowRoot.activeElement) {
-			target = target.shadowRoot.activeElement;
-		}
-
-		let focusableElement;
-		let isSpecialCase = false;
-
-		switch (target.id) {
-		case `${this._id}-firstfe`:
-			focusableElement = getLastFocusableElement(container);
-			isSpecialCase = true;
-			break;
-		case `${this._id}-lastfe`:
-			focusableElement = getFirstFocusableElement(container);
-			isSpecialCase = true;
-			break;
-		case `${this._id}-blocklayer`:
-			focusableElement = this._currentFocusedElement
-				|| getFirstFocusableElement(container);
-			isSpecialCase = true;
-			break;
-		}
-
-		if (focusableElement) {
-			focusableElement.focus();
-		} else if (isSpecialCase) {
-			container.focus();
-		}
-
-		this._currentFocusedElement = focusableElement || document.activeElement;
-	}
-
-	storeCurrentFocus() {
-		let element = document.activeElement;
-
-		while (element.shadowRoot && element.shadowRoot.activeElement) {
-			element = element.shadowRoot.activeElement;
-		}
-
-		this._lastFocusableElement = (element && typeof element.focus === "function") ? element : null;
-	}
-
-	resetFocus() {
-		if (!this._lastFocusableElement) {
-			return;
-		}
-
-		const lastFocusableElement = this._lastFocusableElement;
-		if (lastFocusableElement) {
-			lastFocusableElement.focus();
-		}
-
-		this._lastFocusableElement = null;
-	}
-
-	onExitDOM() {
-		removeBodyStyles();
-	}
-
-	get hasHeader() {
-		const hasHeaderText = this.headerText && this.headerText.length;
-		return !!(hasHeaderText || this.header.length);
-	}
-
-	get hasFooter() {
-		return !!this.footer.length;
-	}
-
-	get role() {
-		return "heading";
-	}
-}
-
+let Popup = Popup_1 = class Popup extends UI5Element {
+    constructor() {
+        super();
+        this._resizeHandler = this._resize.bind(this);
+    }
+    static get render() {
+        return litRender;
+    }
+    static get styles() {
+        return styles;
+    }
+    static get template() {
+        return PopupTemplate;
+    }
+    static get staticAreaTemplate() {
+        return PopupBlockLayer;
+    }
+    static get staticAreaStyles() {
+        return staticAreaStyles;
+    }
+    onBeforeRendering() {
+        this._blockLayerHidden = !this.isOpen() || !this.isTopModalPopup;
+    }
+    onEnterDOM() {
+        ResizeHandler.register(this, this._resizeHandler);
+    }
+    onExitDOM() {
+        if (this.isOpen()) {
+            Popup_1.unblockPageScrolling(this);
+            this._removeOpenedPopup();
+        }
+        ResizeHandler.deregister(this, this._resizeHandler);
+    }
+    get _displayProp() {
+        return "block";
+    }
+    _resize() {
+        this.mediaRange = MediaRange.getCurrentRange(MediaRange.RANGESETS.RANGE_4STEPS, this.getDomRef().offsetWidth);
+    }
+    /**
+     * Prevents the user from interacting with the content under the block layer
+     */
+    _preventBlockLayerFocus(e) {
+        e.preventDefault();
+    }
+    /**
+     * Temporarily removes scrollbars from the html element
+     * @protected
+     */
+    static blockPageScrolling(popup) {
+        pageScrollingBlockers.add(popup);
+        if (pageScrollingBlockers.size !== 1) {
+            return;
+        }
+        document.documentElement.classList.add("ui5-popup-scroll-blocker");
+    }
+    /**
+     * Restores scrollbars on the html element, if needed
+     * @protected
+     */
+    static unblockPageScrolling(popup) {
+        pageScrollingBlockers.delete(popup);
+        if (pageScrollingBlockers.size !== 0) {
+            return;
+        }
+        document.documentElement.classList.remove("ui5-popup-scroll-blocker");
+    }
+    _scroll(e) {
+        this.fireEvent("scroll", {
+            scrollTop: e.target.scrollTop,
+            targetRef: e.target,
+        });
+    }
+    _onkeydown(e) {
+        const isTabOutAttempt = e.target === this._root && isTabPrevious(e);
+        // if the popup is closed, focus is already moved, so Enter keydown may result in click on the newly focused element
+        const isEnterOnClosedPopupChild = isEnter(e) && !this.isOpen();
+        if (isTabOutAttempt || isEnterOnClosedPopupChild) {
+            e.preventDefault();
+        }
+    }
+    _onfocusout(e) {
+        // relatedTarget is the element, which will get focus. If no such element exists, focus the root.
+        // This happens after the mouse is released in order to not interrupt text selection.
+        if (!e.relatedTarget) {
+            this._shouldFocusRoot = true;
+        }
+    }
+    _onmousedown(e) {
+        this._root.removeAttribute("tabindex");
+        if (this.shadowRoot.contains(e.target)) {
+            this._shouldFocusRoot = true;
+        }
+        else {
+            this._shouldFocusRoot = false;
+        }
+    }
+    _onmouseup() {
+        this._root.tabIndex = -1;
+        if (this._shouldFocusRoot) {
+            if (isChrome()) {
+                this._root.focus();
+            }
+            this._shouldFocusRoot = false;
+        }
+    }
+    /**
+     * Focus trapping
+     * @private
+     */
+    async forwardToFirst() {
+        const firstFocusable = await getFirstFocusableElement(this);
+        if (firstFocusable) {
+            firstFocusable.focus({ focusVisible: true });
+        }
+        else {
+            this._root.focus();
+        }
+    }
+    /**
+     * Focus trapping
+     * @private
+     */
+    async forwardToLast() {
+        const lastFocusable = await getLastFocusableElement(this);
+        if (lastFocusable) {
+            lastFocusable.focus({ focusVisible: true });
+        }
+        else {
+            this._root.focus();
+        }
+    }
+    /**
+     * Use this method to focus the element denoted by "initialFocus", if provided, or the first focusable element otherwise.
+     * @protected
+     */
+    async applyInitialFocus() {
+        await this.applyFocus();
+    }
+    /**
+     * Focuses the element denoted by <code>initialFocus</code>, if provided,
+     * or the first focusable element otherwise.
+     * @public
+     * @method
+     * @name sap.ui.webc.main.Popup#applyFocus
+     * @async
+     * @returns {Promise} Promise that resolves when the focus is applied
+     */
+    async applyFocus() {
+        await this._waitForDomRef();
+        const element = this.getRootNode().getElementById(this.initialFocus)
+            || document.getElementById(this.initialFocus)
+            || await getFirstFocusableElement(this)
+            || this._root; // in case of no focusable content focus the root
+        if (element) {
+            if (element === this._root) {
+                element.tabIndex = -1;
+            }
+            element.focus({ focusVisible: true });
+        }
+    }
+    /**
+     * Tells if the component is opened
+     * @public
+     * @method
+     * @name sap.ui.webc.main.Popup#isOpen
+     * @returns {boolean}
+     */
+    isOpen() {
+        return this.opened;
+    }
+    isFocusWithin() {
+        return isFocusedElementWithinNode(this._root);
+    }
+    /**
+     * Shows the block layer (for modal popups only) and sets the correct z-index for the purpose of popup stacking
+     * @protected
+     */
+    async _open(preventInitialFocus) {
+        const prevented = !this.fireEvent("before-open", {}, true, false);
+        if (prevented) {
+            return;
+        }
+        if (this.isModal && !this.shouldHideBackdrop) {
+            // create static area item ref for block layer
+            this.getStaticAreaItemDomRef();
+            this._blockLayerHidden = false;
+            Popup_1.blockPageScrolling(this);
+        }
+        this._zIndex = getNextZIndex();
+        this.style.zIndex = this._zIndex?.toString() || "";
+        this._focusedElementBeforeOpen = getFocusedElement();
+        this._show();
+        if (!this._disableInitialFocus && !preventInitialFocus) {
+            this.applyInitialFocus();
+        }
+        this._addOpenedPopup();
+        this.opened = true;
+        this.open = true;
+        await renderFinished();
+        this.fireEvent("after-open", {}, false, false);
+    }
+    /**
+     * Adds the popup to the "opened popups registry"
+     * @protected
+     */
+    _addOpenedPopup() {
+        addOpenedPopup(this);
+    }
+    /**
+     * Hides the block layer (for modal popups only)
+     * @public
+     * @method
+     * @name sap.ui.webc.main.Popup#close
+     * @returns {void}
+     */
+    close(escPressed = false, preventRegistryUpdate = false, preventFocusRestore = false) {
+        if (!this.opened) {
+            return;
+        }
+        const prevented = !this.fireEvent("before-close", { escPressed }, true, false);
+        if (prevented) {
+            return;
+        }
+        if (this.isModal) {
+            this._blockLayerHidden = true;
+            Popup_1.unblockPageScrolling(this);
+        }
+        this.hide();
+        this.opened = false;
+        this.open = false;
+        if (!preventRegistryUpdate) {
+            this._removeOpenedPopup();
+        }
+        if (!this.preventFocusRestore && !preventFocusRestore) {
+            this.resetFocus();
+        }
+        this.fireEvent("after-close", {}, false, false);
+    }
+    /**
+     * Removes the popup from the "opened popups registry"
+     * @protected
+     */
+    _removeOpenedPopup() {
+        removeOpenedPopup(this);
+    }
+    /**
+     * Returns the focus to the previously focused element
+     * @protected
+     */
+    resetFocus() {
+        if (!this._focusedElementBeforeOpen) {
+            return;
+        }
+        this._focusedElementBeforeOpen.focus({ focusVisible: true });
+        this._focusedElementBeforeOpen = null;
+    }
+    /**
+     * Sets "block" display to the popup. The property can be overriden by derivatives of Popup.
+     * @protected
+     */
+    _show() {
+        this.style.display = this._displayProp;
+    }
+    /**
+     * Sets "none" display to the popup
+     * @protected
+     */
+    hide() {
+        this.style.display = "none";
+    }
+    /**
+     * Ensures ariaLabel is never null or empty string
+     * @returns {string|undefined}
+     * @protected
+     */
+    get _ariaLabel() {
+        return getEffectiveAriaLabelText(this);
+    }
+    get _root() {
+        return this.shadowRoot.querySelector(".ui5-popup-root");
+    }
+    get _role() {
+        return "dialog";
+    }
+    get contentDOM() {
+        return this.shadowRoot.querySelector(".ui5-popup-content");
+    }
+    get styles() {
+        return {
+            root: {},
+            content: {},
+            blockLayer: {
+                "zIndex": this._zIndex ? this._zIndex - 1 : "",
+            },
+        };
+    }
+    get classes() {
+        return {
+            root: {
+                "ui5-popup-root": true,
+                "ui5-content-native-scrollbars": getEffectiveScrollbarStyle(),
+            },
+            content: {
+                "ui5-popup-content": true,
+            },
+        };
+    }
+};
+__decorate([
+    property()
+], Popup.prototype, "initialFocus", void 0);
+__decorate([
+    property({ type: Boolean })
+], Popup.prototype, "preventFocusRestore", void 0);
+__decorate([
+    property({ type: Boolean })
+], Popup.prototype, "open", void 0);
+__decorate([
+    property({ type: Boolean, noAttribute: true })
+], Popup.prototype, "opened", void 0);
+__decorate([
+    property({ defaultValue: undefined })
+], Popup.prototype, "accessibleName", void 0);
+__decorate([
+    property({ defaultValue: "" })
+], Popup.prototype, "accessibleNameRef", void 0);
+__decorate([
+    property()
+], Popup.prototype, "mediaRange", void 0);
+__decorate([
+    property({ type: Boolean })
+], Popup.prototype, "_disableInitialFocus", void 0);
+__decorate([
+    property({ type: Boolean })
+], Popup.prototype, "_blockLayerHidden", void 0);
+__decorate([
+    property({ type: Boolean, noAttribute: true })
+], Popup.prototype, "isTopModalPopup", void 0);
+__decorate([
+    slot({ type: HTMLElement, "default": true })
+], Popup.prototype, "content", void 0);
+Popup = Popup_1 = __decorate([
+    event("before-open")
+    /**
+     * Fired after the component is opened. <b>This event does not bubble.</b>
+     *
+     * @public
+     * @event sap.ui.webc.main.Popup#after-open
+     */
+    ,
+    event("after-open")
+    /**
+     * Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing. <b>This event does not bubble.</b>
+     *
+     * @public
+     * @event sap.ui.webc.main.Popup#before-close
+     * @allowPreventDefault
+     * @param {boolean} escPressed Indicates that <code>ESC</code> key has triggered the event.
+     */
+    ,
+    event("before-close", {
+        escPressed: { type: Boolean },
+    })
+    /**
+     * Fired after the component is closed. <b>This event does not bubble.</b>
+     *
+     * @public
+     * @event sap.ui.webc.main.Popup#after-close
+     */
+    ,
+    event("after-close")
+    /**
+     * Fired whenever the popup content area is scrolled
+     *
+     * @private
+     * @event sap.ui.webc.main.Popup#scroll
+     */
+    ,
+    event("scroll")
+], Popup);
 export default Popup;
+//# sourceMappingURL=Popup.js.map