@sbb-esta/lyne-elements 4.8.1 → 4.9.0

package/development/popover.component-dRXm7_Mv.js

@@ -0,0 +1,736 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, html, isServer, nothing } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbOpenCloseBaseElement } from "./core/base-elements.js";
+import { forceType, idReference } from "./core/decorators.js";
+import { isZeroAnimationDuration } from "./core/dom.js";
+import { composedPathHasAttribute } from "./core/eventing.js";
+import { ɵstateController } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { SbbEscapableOverlayController, SbbLanguageController, SbbMediaQueryPointerCoarse } from "./core/controllers.js";
+import { i18nClosePopover } from "./core/i18n.js";
+import { ref } from "lit/directives/ref.js";
+import { getElementPosition, isEventOnElement, removeAriaOverlayTriggerAttributes, setAriaOverlayTriggerAttributes } from "./core/overlay.js";
+import { IS_FOCUSABLE_QUERY, SbbFocusTrapController, isFakeMousedownFromScreenReader, sbbInputModalityDetector } from "./core/a11y.js";
+import { readConfig } from "./core/config.js";
+import "./button/secondary-button.js";
+//#region src/elements/popover/popover.scss?lit&inline
+var popover_default = css`:host {
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-default);
+  --sbb-focus-outline-color: light-dark(
+    var(--sbb-focus-outline-color-default),
+    var(--sbb-focus-outline-color-dark)
+  );
+  --sbb-popover-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-4x)
+  );
+  --_sbb-popover-inset: 0 auto auto 0;
+  --_sbb-popover-transform: translateY(var(--sbb-spacing-fixed-2x));
+  outline: none !important;
+  display: none;
+}
+
+:host(:is(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]), :is(:state(state-closing),[state--state-closing]))) {
+  --_sbb-popover-inset: 0;
+  display: block;
+}
+
+:host(:is(:state(position-above),[state--position-above])) {
+  --_sbb-popover-transform: translateY(calc(var(--sbb-spacing-fixed-2x) * -1));
+}
+
+:host(:not([hide-close-button], :is(:state(hover-trigger),[state--hover-trigger]))) {
+  --sbb-popover-min-height: calc(var(--sbb-size-element-xs) + 2 * var(--sbb-popover-padding));
+}
+
+.sbb-popover::after,
+.sbb-popover__content::before {
+  content: "";
+  position: absolute;
+  display: block;
+  width: var(--sbb-popover-arrow-size);
+  height: var(--sbb-popover-arrow-size);
+  left: var(--_sbb-popover-arrow-position-x, 0);
+  bottom: calc(100% - var(--sbb-popover-arrow-size) / 2);
+  background-color: var(--sbb-popover-background);
+  border-radius: var(--sbb-border-radius-2x) 0;
+  transform: rotate(45deg);
+}
+
+.sbb-popover__container {
+  position: fixed;
+  inset: var(--_sbb-popover-inset);
+  pointer-events: none;
+  z-index: var(--sbb-popover-z-index, var(--sbb-overlay-default-z-index));
+}
+
+.sbb-popover {
+  box-shadow: var(--sbb-box-shadow-level-5-hard);
+  display: none;
+  position: var(--sbb-popover-position, absolute);
+  pointer-events: all;
+  top: var(--_sbb-popover-position-y, 0);
+  bottom: unset;
+  left: var(--_sbb-popover-position-x, 0);
+  right: unset;
+  border: none;
+  border-radius: var(--sbb-popover-border-radius);
+  padding: 0;
+  max-width: var(--sbb-popover-max-width);
+  width: max-content;
+  background-color: var(--sbb-popover-background);
+  outline: none;
+}
+:host(:focus-visible) .sbb-popover {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+}
+:host(:is(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]), :is(:state(state-closing),[state--state-closing]))) .sbb-popover {
+  display: block;
+  animation-name: open;
+  animation-duration: var(--sbb-popover-animation-duration);
+  animation-timing-function: var(--sbb-popover-animation-easing);
+}
+:host(:is(:state(state-closing),[state--state-closing])) .sbb-popover {
+  pointer-events: none;
+  animation-name: close;
+  animation-duration: var(--sbb-popover-animation-duration);
+  animation-timing-function: var(--sbb-popover-animation-easing);
+}
+.sbb-popover::after {
+  z-index: -1;
+  box-shadow: var(--sbb-box-shadow-level-5-hard);
+}
+@media (forced-colors: active) {
+  .sbb-popover::after {
+    outline: var(--sbb-border-width-1x) solid CanvasText;
+  }
+}
+:host(:is(:state(position-above),[state--position-above])) .sbb-popover::after {
+  top: calc(100% - var(--sbb-popover-arrow-size) / 2);
+}
+@media (forced-colors: active) {
+  .sbb-popover {
+    outline: var(--sbb-border-width-1x) solid CanvasText;
+  }
+}
+.sbb-popover::before {
+  content: "";
+  display: block;
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  background-color: transparent;
+}
+:host(:is(:state(position-below),[state--position-below])) .sbb-popover::before {
+  inset-block-start: calc(-1 * var(--sbb-spacing-fixed-6x));
+}
+:host(:is(:state(position-above),[state--position-above])) .sbb-popover::before {
+  inset-block-end: calc(-1 * var(--sbb-spacing-fixed-6x));
+}
+
+.sbb-popover__content {
+  display: flex;
+  gap: var(--sbb-spacing-fixed-4x);
+  border-radius: var(--sbb-popover-border-radius);
+  padding-block: var(--sbb-popover-padding) 0;
+  padding-inline: var(--sbb-popover-padding);
+  outline: none;
+  background-color: var(--sbb-popover-background);
+  flex-direction: row-reverse;
+  min-height: var(--sbb-popover-min-height);
+}
+:host(:is(:state(position-above),[state--position-above])) .sbb-popover__content::before {
+  top: calc(100% - var(--sbb-popover-arrow-size) / 2);
+}
+
+.sbb-popover__scrollable-content {
+  --sbb-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: color-mix(in srgb, var(--sbb-color-black) 30%, transparent);
+  --sbb-scrollbar-color: light-dark(
+    color-mix(in srgb, var(--sbb-color-black) 30%, transparent),
+    color-mix(in srgb, var(--sbb-color-white) 30%, transparent)
+  );
+  --sbb-scrollbar-color-hover: color-mix(in srgb, var(--sbb-color-black) 60%, transparent);
+  --sbb-scrollbar-color-hover: light-dark(
+    color-mix(in srgb, var(--sbb-color-black) 60%, transparent),
+    color-mix(in srgb, var(--sbb-color-white) 60%, transparent)
+  );
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+}
+.sbb-popover__scrollable-content::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-popover__scrollable-content::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-popover__scrollable-content::-webkit-scrollbar-thumb {
+  background-color: var(--sbb-scrollbar-color, currentcolor);
+  border: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width))) solid transparent;
+  border-radius: var(--sbb-border-radius-4x);
+  background-clip: padding-box;
+}
+.sbb-popover__scrollable-content::-webkit-scrollbar-thumb:hover {
+  background-color: var(--sbb-scrollbar-color-hover, currentcolor);
+  border-width: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width-hover)));
+}
+.sbb-popover__scrollable-content::-webkit-scrollbar-button, .sbb-popover__scrollable-content::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-popover__scrollable-content {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+.sbb-popover__scrollable-content {
+  display: block;
+  padding-block-end: var(--sbb-popover-padding);
+  max-height: calc(var(--_sbb-popover-max-height));
+  overflow: auto;
+}
+
+@keyframes open {
+  from {
+    opacity: 0;
+    transform: var(--_sbb-popover-transform);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+@keyframes close {
+  from {
+    opacity: 1;
+    transform: translateY(0);
+  }
+  to {
+    opacity: 0;
+    transform: var(--_sbb-popover-transform);
+  }
+}`;
+//#endregion
+//#region src/elements/popover/popover.component.ts
+var VERTICAL_OFFSET = 16;
+var HORIZONTAL_OFFSET = 32;
+var nextId = 0;
+var popoversRef = /* @__PURE__ */ new Set();
+var pointerCoarse = isServer ? false : matchMedia(SbbMediaQueryPointerCoarse).matches;
+var SbbPopoverBaseElement = (() => {
+	let _classSuper = SbbOpenCloseBaseElement;
+	let _trigger_decorators;
+	let _trigger_initializers = [];
+	let _trigger_extraInitializers = [];
+	return class SbbPopoverBaseElement extends _classSuper {
+		constructor() {
+			super(...arguments);
+			this.#trigger_accessor_storage = __runInitializers(this, _trigger_initializers, null);
+			this._nextFocusedElement = __runInitializers(this, _trigger_extraInitializers);
+			this._skipCloseFocus = false;
+			this._escapableOverlayController = new SbbEscapableOverlayController(this);
+			this._focusTrapController = new SbbFocusTrapController(this);
+			this._blurTimeout = null;
+			this._pointerDownListener = (event) => {
+				this._isPointerDownEventOnPopover = isEventOnElement(this.overlay, event);
+			};
+			this._closeOnBackdropClick = (event) => {
+				const composedPath = event.composedPath();
+				if (!this._isPointerDownEventOnPopover && !isEventOnElement(this.overlay, event) && (!this.trigger || !composedPath.includes(this.trigger))) {
+					this._nextFocusedElement = composedPath.filter((el) => el instanceof window.HTMLElement).find((el) => el.matches(IS_FOCUSABLE_QUERY));
+					clearTimeout(this.closeTimeout);
+					this.close();
+				}
+			};
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_trigger_decorators = [idReference(), property()];
+			__esDecorate(this, null, _trigger_decorators, {
+				kind: "accessor",
+				name: "trigger",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "trigger" in obj,
+					get: (obj) => obj.trigger,
+					set: (obj, value) => {
+						obj.trigger = value;
+					}
+				},
+				metadata: _metadata
+			}, _trigger_initializers, _trigger_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.styles = [boxSizingStyles, popover_default];
+		}
+		#trigger_accessor_storage;
+		/**
+		* The element that will trigger the popover overlay.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get trigger() {
+			return this.#trigger_accessor_storage;
+		}
+		set trigger(value) {
+			this.#trigger_accessor_storage = value;
+		}
+		/** Opens the popover on trigger click. */
+		open() {
+			if (this.state !== "closed" && this.state !== "closing" || !this.overlay || !this.dispatchBeforeOpenEvent()) return;
+			for (const popover of popoversRef) if (popover.state === "opened" || popover.state === "opening") popover.close();
+			this.showPopover?.();
+			this.state = "opening";
+			this.inert = true;
+			this._setPopoverPosition();
+			this._attachWindowEvents();
+			this._escapableOverlayController.connect();
+			this._triggerElement?.setAttribute("aria-expanded", "true");
+			this._nextFocusedElement = void 0;
+			this._skipCloseFocus = false;
+			if (this._isZeroAnimationDuration()) this._handleOpening();
+		}
+		/** Closes the popover. */
+		close(target) {
+			if (this.state !== "opened" && this.state !== "opening") return;
+			this._popoverCloseElement = target;
+			if (!this.dispatchBeforeCloseEvent({ closeTarget: target ?? null })) return;
+			this.state = "closing";
+			this.inert = true;
+			this._triggerElement?.setAttribute("aria-expanded", "false");
+			if (this._isZeroAnimationDuration()) this._handleClosing();
+		}
+		_isZeroAnimationDuration() {
+			return isZeroAnimationDuration(this, "--sbb-popover-animation-duration");
+		}
+		_handleClosing() {
+			this.state = "closed";
+			this.hidePopover?.();
+			this.overlay?.firstElementChild?.scrollTo(0, 0);
+			this.removeAttribute("tabindex");
+			if (!this._skipCloseFocus) (this._nextFocusedElement || this._triggerElement)?.focus();
+			this._escapableOverlayController.disconnect();
+			this._openStateController?.abort();
+			this._focusTrapController.enabled = false;
+			this.dispatchCloseEvent({ closeTarget: this._popoverCloseElement ?? null });
+		}
+		_handleOpening() {
+			this.state = "opened";
+			this.inert = false;
+			this._setPopoverFocus();
+			this._focusTrapController.enabled = true;
+			this.dispatchOpenEvent();
+		}
+		connectedCallback() {
+			this.popover = "manual";
+			super.connectedCallback();
+			this.id ||= `sbb-popover-${++nextId}`;
+			this.state = "closed";
+			popoversRef.add(this);
+			if (this.hasUpdated) this._configureTrigger();
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (!isServer && (!name || name === "trigger" || name === "hoverTrigger") && this.hasUpdated) this._configureTrigger();
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this._configureTrigger();
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this._triggerElement = null;
+			this._triggerAbortController?.abort();
+			this._openStateController?.abort();
+			popoversRef.delete(this);
+			if (this._blurTimeout) clearTimeout(this._blurTimeout);
+		}
+		_configureTrigger() {
+			if (isServer) return;
+			else if (this.hydrationRequired) {
+				this.hydrationComplete.then(() => this._configureTrigger());
+				return;
+			}
+			this.configureTrigger(this._triggerElement ?? null);
+		}
+		configureTrigger(_oldTrigger) {
+			this._triggerAbortController?.abort();
+			removeAriaOverlayTriggerAttributes(this._triggerElement);
+			this._triggerElement = this.trigger;
+			if (!this._triggerElement) return;
+			setAriaOverlayTriggerAttributes(this._triggerElement, "dialog", this.id, this.state);
+			this._triggerAbortController = new AbortController();
+			this.registerTriggerListeners(this._triggerAbortController.signal);
+		}
+		registerTriggerListeners(signal) {
+			this._triggerElement.addEventListener("click", () => this.open(), { signal });
+		}
+		_attachWindowEvents() {
+			this._openStateController = new AbortController();
+			document.addEventListener("scroll", () => this._setPopoverPosition(), {
+				passive: true,
+				signal: this._openStateController.signal,
+				capture: true
+			});
+			window.addEventListener("resize", () => this._setPopoverPosition(), {
+				passive: true,
+				signal: this._openStateController.signal
+			});
+			window.addEventListener("pointerdown", this._pointerDownListener, { signal: this._openStateController.signal });
+			window.addEventListener("pointerup", this._closeOnBackdropClick, { signal: this._openStateController.signal });
+		}
+		_closeOnSbbPopoverCloseClick(event) {
+			const closeElement = composedPathHasAttribute(event, "sbb-popover-close", this);
+			if (closeElement && !closeElement.hasAttribute("disabled")) {
+				clearTimeout(this.closeTimeout);
+				this.close(closeElement);
+			}
+		}
+		_onPopoverAnimationEnd(event) {
+			if (event.animationName === "open" && this.state === "opening") this._handleOpening();
+			else if (event.animationName === "close" && this.state === "closing") this._handleClosing();
+		}
+		_setPopoverFocus() {
+			if (!this._focusTrapController.focusInitialElement() && this._openStateController) {
+				this.setAttribute("tabindex", "0");
+				this.focus();
+				this.addEventListener("blur", (e) => {
+					this._blurTimeout = setTimeout(() => {
+						if (document.visibilityState !== "hidden") {
+							this.removeAttribute("tabindex");
+							if (this.contains(e.relatedTarget) || e.relatedTarget === this.trigger) return;
+							if (this.state === "opened" || this.state === "opening") this._skipCloseFocus = true;
+							this.close();
+						}
+					});
+				}, { signal: this._openStateController.signal });
+			}
+		}
+		_setPopoverPosition() {
+			if (!this.overlay || !this._triggerElement) return;
+			const popoverPosition = getElementPosition(this.overlay, this._triggerElement, this.shadowRoot.querySelector(".sbb-popover__container"), {
+				verticalOffset: VERTICAL_OFFSET,
+				horizontalOffset: HORIZONTAL_OFFSET,
+				centered: true,
+				responsiveHeight: true
+			});
+			const verticalPosition = popoverPosition.alignment.vertical;
+			for (const position of ["above", "below"]) this.toggleState(`position-${position}`, position === verticalPosition);
+			const arrowXPosition = this._triggerElement.getBoundingClientRect().left - popoverPosition.left + this._triggerElement.clientWidth / 2 - 8;
+			this.style.setProperty("--_sbb-popover-position-x", `${popoverPosition.left}px`);
+			this.style.setProperty("--_sbb-popover-position-y", `${popoverPosition.top}px`);
+			this.style.setProperty("--_sbb-popover-arrow-position-x", `${arrowXPosition}px`);
+			this.style.setProperty("--_sbb-popover-max-height", popoverPosition.maxHeight);
+		}
+		dispatchBeforeCloseEvent(detail) {
+			/**
+			* @type {CustomEvent<{ closeTarget: HTMLElement | null }>}
+			* Emits whenever the component begins the closing transition. Can be canceled.
+			*/
+			return this.dispatchEvent(new CustomEvent("beforeclose", {
+				detail,
+				cancelable: true
+			}));
+		}
+		dispatchCloseEvent(detail) {
+			/**
+			* @type {CustomEvent<{ closeTarget: HTMLElement | null }>}
+			* Emits whenever the component is closed.
+			*/
+			return this.dispatchEvent(new CustomEvent("close", { detail }));
+		}
+		render() {
+			return html`
+      <div class="sbb-popover__container">
+        <div
+          @animationend=${this._onPopoverAnimationEnd}
+          class="sbb-popover"
+          role="tooltip"
+          ${ref((el) => this.overlay = el)}
+        >
+          <div
+            @click=${(event) => this._closeOnSbbPopoverCloseClick(event)}
+            class="sbb-popover__content"
+          >
+            ${this.renderContent()}
+          </div>
+        </div>
+      </div>
+    `;
+		}
+	};
+})();
+/**
+* It displays contextual information within a popover.
+*
+* @slot - Use the unnamed slot to add content into the popover.
+* @cssprop [--sbb-popover-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+* the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+* component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+*/
+var SbbPopoverElement = (() => {
+	let _classSuper = SbbPopoverBaseElement;
+	let _instanceExtraInitializers = [];
+	let _hideCloseButton_decorators;
+	let _hideCloseButton_initializers = [];
+	let _hideCloseButton_extraInitializers = [];
+	let _hoverTrigger_decorators;
+	let _hoverTrigger_initializers = [];
+	let _hoverTrigger_extraInitializers = [];
+	let _set_openDelay_decorators;
+	let _set_closeDelay_decorators;
+	let _accessibilityCloseLabel_decorators;
+	let _accessibilityCloseLabel_initializers = [];
+	let _accessibilityCloseLabel_extraInitializers = [];
+	return class SbbPopoverElement extends _classSuper {
+		constructor() {
+			super(...arguments);
+			this.#hideCloseButton_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _hideCloseButton_initializers, false));
+			this.#hoverTrigger_accessor_storage = (__runInitializers(this, _hideCloseButton_extraInitializers), __runInitializers(this, _hoverTrigger_initializers, false));
+			this._openDelay = __runInitializers(this, _hoverTrigger_extraInitializers);
+			this.#accessibilityCloseLabel_accessor_storage = __runInitializers(this, _accessibilityCloseLabel_initializers, "");
+			this._hoverTrigger = (__runInitializers(this, _accessibilityCloseLabel_extraInitializers), false);
+			this._language = new SbbLanguageController(this);
+			this._overlayAbortController = null;
+			this._onTriggerMouseEnter = () => {
+				if (this.state === "closed" || this.state === "closing") this._openTimeout = setTimeout(() => {
+					sbbInputModalityDetector.reset();
+					this.open();
+				}, this.openDelay);
+				else clearTimeout(this.closeTimeout);
+			};
+			this._onTriggerMouseLeave = () => {
+				if (this.state === "opened" || this.state === "opening") this.closeTimeout = setTimeout(() => this.close(), this.closeDelay);
+				else clearTimeout(this._openTimeout);
+			};
+			this._onOverlayMouseEnter = () => {
+				if (this.state !== "opening") clearTimeout(this.closeTimeout);
+			};
+			this._onOverlayMouseLeave = () => {
+				if (this.state !== "opening") this.closeTimeout = setTimeout(() => this.close(), this.closeDelay);
+			};
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_hideCloseButton_decorators = [forceType(), property({
+				attribute: "hide-close-button",
+				type: Boolean,
+				reflect: true
+			})];
+			_hoverTrigger_decorators = [forceType(), property({
+				attribute: "hover-trigger",
+				type: Boolean
+			})];
+			_set_openDelay_decorators = [property({
+				attribute: "open-delay",
+				type: Number
+			})];
+			_set_closeDelay_decorators = [property({
+				attribute: "close-delay",
+				type: Number
+			})];
+			_accessibilityCloseLabel_decorators = [forceType(), property({ attribute: "accessibility-close-label" })];
+			__esDecorate(this, null, _hideCloseButton_decorators, {
+				kind: "accessor",
+				name: "hideCloseButton",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "hideCloseButton" in obj,
+					get: (obj) => obj.hideCloseButton,
+					set: (obj, value) => {
+						obj.hideCloseButton = value;
+					}
+				},
+				metadata: _metadata
+			}, _hideCloseButton_initializers, _hideCloseButton_extraInitializers);
+			__esDecorate(this, null, _hoverTrigger_decorators, {
+				kind: "accessor",
+				name: "hoverTrigger",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "hoverTrigger" in obj,
+					get: (obj) => obj.hoverTrigger,
+					set: (obj, value) => {
+						obj.hoverTrigger = value;
+					}
+				},
+				metadata: _metadata
+			}, _hoverTrigger_initializers, _hoverTrigger_extraInitializers);
+			__esDecorate(this, null, _set_openDelay_decorators, {
+				kind: "setter",
+				name: "openDelay",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "openDelay" in obj,
+					set: (obj, value) => {
+						obj.openDelay = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_closeDelay_decorators, {
+				kind: "setter",
+				name: "closeDelay",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "closeDelay" in obj,
+					set: (obj, value) => {
+						obj.closeDelay = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _accessibilityCloseLabel_decorators, {
+				kind: "accessor",
+				name: "accessibilityCloseLabel",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "accessibilityCloseLabel" in obj,
+					get: (obj) => obj.accessibilityCloseLabel,
+					set: (obj, value) => {
+						obj.accessibilityCloseLabel = value;
+					}
+				},
+				metadata: _metadata
+			}, _accessibilityCloseLabel_initializers, _accessibilityCloseLabel_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-popover";
+		}
+		#hideCloseButton_accessor_storage;
+		/** Whether the close button should be hidden. */
+		get hideCloseButton() {
+			return this.#hideCloseButton_accessor_storage;
+		}
+		set hideCloseButton(value) {
+			this.#hideCloseButton_accessor_storage = value;
+		}
+		#hoverTrigger_accessor_storage;
+		/** Whether the popover should be triggered on hover. */
+		get hoverTrigger() {
+			return this.#hoverTrigger_accessor_storage;
+		}
+		set hoverTrigger(value) {
+			this.#hoverTrigger_accessor_storage = value;
+		}
+		/**
+		* Open the popover after a given delay in milliseconds.
+		* Global configuration is used as default, if not set.
+		*
+		* @default 0
+		*/
+		set openDelay(value) {
+			this._openDelay = +value;
+		}
+		get openDelay() {
+			return this._openDelay ?? readConfig().popover?.openDelay ?? 0;
+		}
+		/**
+		* Close the popover after a given delay in milliseconds.
+		* Global configuration is used as default, if not set.
+		*
+		* @default 0
+		*/
+		set closeDelay(value) {
+			this._closeDelay = +value;
+		}
+		get closeDelay() {
+			return this._closeDelay ?? readConfig().popover?.closeDelay ?? 0;
+		}
+		#accessibilityCloseLabel_accessor_storage;
+		/** This will be forwarded as aria-label to the close button element. */
+		get accessibilityCloseLabel() {
+			return this.#accessibilityCloseLabel_accessor_storage;
+		}
+		set accessibilityCloseLabel(value) {
+			this.#accessibilityCloseLabel_accessor_storage = value;
+		}
+		configureTrigger(oldTrigger) {
+			const hoverTrigger = this.hoverTrigger && !pointerCoarse;
+			if (this.trigger === oldTrigger && hoverTrigger === this._hoverTrigger) return;
+			if (this._hoverTrigger !== hoverTrigger) {
+				this._hoverTrigger = hoverTrigger;
+				this.toggleState("hover-trigger", this._hoverTrigger);
+				this._registerOverlayListeners();
+			}
+			super.configureTrigger(oldTrigger);
+		}
+		_registerOverlayListeners() {
+			this._overlayAbortController?.abort();
+			if (this._hoverTrigger) {
+				this._overlayAbortController = new AbortController();
+				this.overlay?.addEventListener("mouseenter", () => this._onOverlayMouseEnter(), { signal: this._overlayAbortController.signal });
+				this.overlay?.addEventListener("mouseleave", () => this._onOverlayMouseLeave(), { signal: this._overlayAbortController.signal });
+			}
+		}
+		registerTriggerListeners(signal) {
+			if (this._hoverTrigger && this.trigger) {
+				this.trigger.addEventListener("mouseenter", this._onTriggerMouseEnter, { signal });
+				this.trigger.addEventListener("mouseleave", this._onTriggerMouseLeave, { signal });
+				this.trigger.addEventListener("keydown", (evt) => {
+					if (evt.code === "Space" || evt.code === "Enter") this.open();
+				}, { signal });
+				this.trigger.addEventListener("mousedown", (evt) => {
+					if (isFakeMousedownFromScreenReader(evt)) this.open();
+				}, { signal });
+			} else super.registerTriggerListeners(signal);
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this._registerOverlayListeners();
+		}
+		open() {
+			super.open();
+			if (this.hoverTrigger && this.trigger) ɵstateController(this.trigger).add("force-hover");
+		}
+		close() {
+			super.close();
+			ɵstateController(this.trigger)?.delete("force-hover");
+		}
+		renderContent() {
+			const closeButton = html`
+      <sbb-secondary-button
+        aria-label=${this.accessibilityCloseLabel || i18nClosePopover[this._language.current]}
+        size="s"
+        type="button"
+        icon-name="cross-small"
+        sbb-popover-close
+      ></sbb-secondary-button>
+    `;
+			return html`
+      ${!this.hideCloseButton && !this._hoverTrigger ? closeButton : nothing}
+      <span class="sbb-popover__scrollable-content">
+        <slot>No content</slot>
+      </span>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbPopoverElement as n, SbbPopoverBaseElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"popover.component-dRXm7_Mv.js","names":[],"sources":["../../../src/elements/popover/popover.scss?lit&inline","../../../src/elements/popover/popover.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  // As the popover has always a white background, we have to fix the focus outline color\n  // to default color for cases where the popover is used in a negative context.\n  --sbb-focus-outline-color: light-dark(\n    var(--sbb-focus-outline-color-default),\n    var(--sbb-focus-outline-color-dark)\n  );\n  --sbb-popover-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-4x)\n  );\n  --_sbb-popover-inset: 0 auto auto 0;\n  --_sbb-popover-transform: translateY(var(--sbb-spacing-fixed-2x));\n\n  // Use !important here to not interfere with Firefox focus ring definition\n  // which appears in normalize CSS of several frameworks.\n  outline: none !important;\n  display: none;\n}\n\n:host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) {\n  --_sbb-popover-inset: 0;\n\n  display: block;\n}\n\n:host(:state(position-above)) {\n  --_sbb-popover-transform: translateY(calc(var(--sbb-spacing-fixed-2x) * -1));\n}\n\n:host(:not([hide-close-button], :state(hover-trigger))) {\n  --sbb-popover-min-height: calc(var(--sbb-size-element-xs) + 2 * var(--sbb-popover-padding));\n}\n\n// Popover arrow and arrow top cover\n.sbb-popover::after,\n.sbb-popover__content::before {\n  content: '';\n  position: absolute;\n  display: block;\n  width: var(--sbb-popover-arrow-size);\n  height: var(--sbb-popover-arrow-size);\n  left: var(--_sbb-popover-arrow-position-x, 0);\n  bottom: calc(100% - calc(var(--sbb-popover-arrow-size) / 2));\n  background-color: var(--sbb-popover-background);\n  border-radius: var(--sbb-border-radius-2x) 0;\n  transform: rotate(45deg);\n}\n\n.sbb-popover__container {\n  position: fixed;\n  inset: var(--_sbb-popover-inset);\n  pointer-events: none;\n  z-index: var(--sbb-popover-z-index, var(--sbb-overlay-default-z-index));\n}\n\n.sbb-popover {\n  box-shadow: var(--sbb-box-shadow-level-5-hard);\n  display: none;\n  position: var(--sbb-popover-position, absolute);\n  pointer-events: all;\n  top: var(--_sbb-popover-position-y, 0);\n  bottom: unset;\n  left: var(--_sbb-popover-position-x, 0);\n  right: unset;\n  border: none;\n  border-radius: var(--sbb-popover-border-radius);\n  padding: 0;\n  max-width: var(--sbb-popover-max-width);\n  width: max-content;\n  background-color: var(--sbb-popover-background);\n  outline: none;\n\n  :host(:focus-visible) & {\n    @include sbb.focus-outline;\n  }\n\n  :host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) & {\n    display: block;\n\n    animation: {\n      name: open;\n      duration: var(--sbb-popover-animation-duration);\n      timing-function: var(--sbb-popover-animation-easing);\n    }\n  }\n\n  :host(:state(state-closing)) & {\n    pointer-events: none;\n    animation: {\n      name: close;\n      duration: var(--sbb-popover-animation-duration);\n      timing-function: var(--sbb-popover-animation-easing);\n    }\n  }\n\n  // Popover arrow\n  &::after {\n    z-index: -1;\n    box-shadow: var(--sbb-box-shadow-level-5-hard);\n\n    @include sbb.if-forced-colors {\n      outline: var(--sbb-border-width-1x) solid CanvasText;\n    }\n\n    :host(:state(position-above)) & {\n      top: calc(100% - calc(var(--sbb-popover-arrow-size) / 2));\n    }\n  }\n\n  @include sbb.if-forced-colors {\n    outline: var(--sbb-border-width-1x) solid CanvasText;\n  }\n\n  // Transparent area which increases hover area in order to not trigger closing too early.\n  &::before {\n    content: '';\n    display: block;\n    position: absolute;\n    inset: 0;\n    z-index: -1;\n    background-color: transparent;\n\n    :host(:state(position-below)) & {\n      inset-block-start: calc(-1 * var(--sbb-spacing-fixed-6x));\n    }\n\n    :host(:state(position-above)) & {\n      inset-block-end: calc(-1 * var(--sbb-spacing-fixed-6x));\n    }\n  }\n}\n\n.sbb-popover__content {\n  display: flex;\n  gap: var(--sbb-spacing-fixed-4x);\n  border-radius: var(--sbb-popover-border-radius);\n  padding-block: var(--sbb-popover-padding) 0;\n  padding-inline: var(--sbb-popover-padding);\n  outline: none;\n  background-color: var(--sbb-popover-background);\n  flex-direction: row-reverse;\n  min-height: var(--sbb-popover-min-height);\n\n  :host(:state(position-above)) & {\n    &::before {\n      top: calc(100% - calc(var(--sbb-popover-arrow-size) / 2));\n    }\n  }\n}\n\n.sbb-popover__scrollable-content {\n  @include sbb.scrollbar;\n\n  display: block;\n  padding-block-end: var(--sbb-popover-padding);\n  max-height: calc(var(--_sbb-popover-max-height));\n  overflow: auto;\n}\n\n@keyframes open {\n  from {\n    opacity: 0;\n    transform: var(--_sbb-popover-transform);\n  }\n\n  to {\n    opacity: 1;\n    transform: translateY(0);\n  }\n}\n\n@keyframes close {\n  from {\n    opacity: 1;\n    transform: translateY(0);\n  }\n\n  to {\n    opacity: 0;\n    transform: var(--_sbb-popover-transform);\n  }\n}\n","import type { CSSResultGroup, PropertyDeclaration, PropertyValues, TemplateResult } from 'lit';\nimport { html, isServer, nothing } from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport {\n  IS_FOCUSABLE_QUERY,\n  isFakeMousedownFromScreenReader,\n  SbbFocusTrapController,\n  sbbInputModalityDetector,\n} from '../core/a11y.ts';\nimport { SbbOpenCloseBaseElement } from '../core/base-elements.ts';\nimport { readConfig } from '../core/config.ts';\nimport {\n  SbbEscapableOverlayController,\n  SbbLanguageController,\n  SbbMediaQueryPointerCoarse,\n} from '../core/controllers.ts';\nimport { forceType, idReference } from '../core/decorators.ts';\nimport { isZeroAnimationDuration } from '../core/dom.ts';\nimport { composedPathHasAttribute } from '../core/eventing.ts';\nimport { i18nClosePopover } from '../core/i18n.ts';\nimport { ɵstateController } from '../core/mixins.ts';\nimport {\n  getElementPosition,\n  isEventOnElement,\n  removeAriaOverlayTriggerAttributes,\n  setAriaOverlayTriggerAttributes,\n} from '../core/overlay.ts';\nimport { boxSizingStyles } from '../core/styles.ts';\n\nimport style from './popover.scss?lit&inline';\n\nimport '../button/secondary-button.ts';\n\nconst VERTICAL_OFFSET = 16;\nconst HORIZONTAL_OFFSET = 32;\n\nlet nextId = 0;\n\nconst popoversRef = new Set<SbbPopoverBaseElement>();\nconst pointerCoarse = isServer ? false : matchMedia(SbbMediaQueryPointerCoarse).matches;\n\nexport abstract class SbbPopoverBaseElement extends SbbOpenCloseBaseElement {\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n\n  /**\n   * The element that will trigger the popover overlay.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property()\n  public accessor trigger: HTMLElement | null = null;\n\n  // The element which should receive focus after closing based on where in the backdrop the user clicks.\n  private _nextFocusedElement?: HTMLElement;\n  private _skipCloseFocus: boolean = false;\n  private _popoverCloseElement?: HTMLElement;\n  private _isPointerDownEventOnPopover?: boolean;\n  private _triggerElement?: HTMLElement | null;\n  private _triggerAbortController?: AbortController;\n  private _openStateController?: AbortController;\n  private _escapableOverlayController = new SbbEscapableOverlayController(this);\n  private _focusTrapController = new SbbFocusTrapController(this);\n  private _blurTimeout: ReturnType<typeof setTimeout> | null = null;\n  protected closeTimeout?: ReturnType<typeof setTimeout>;\n  protected overlay?: HTMLDivElement;\n\n  /** Opens the popover on trigger click. */\n  public open(): void {\n    if (\n      (this.state !== 'closed' && this.state !== 'closing') ||\n      !this.overlay ||\n      !this.dispatchBeforeOpenEvent()\n    ) {\n      return;\n    }\n\n    // Close the other popovers\n    for (const popover of popoversRef) {\n      if (popover.state === 'opened' || popover.state === 'opening') {\n        popover.close();\n      }\n    }\n\n    this.showPopover?.();\n    this.state = 'opening';\n    this.inert = true;\n    this._setPopoverPosition();\n    this._attachWindowEvents();\n    this._escapableOverlayController.connect();\n    this._triggerElement?.setAttribute('aria-expanded', 'true');\n    this._nextFocusedElement = undefined;\n    this._skipCloseFocus = false;\n\n    // If the animation duration is zero, the animationend event is not always fired reliably.\n    // In this case we directly set the `opened` state.\n    if (this._isZeroAnimationDuration()) {\n      this._handleOpening();\n    }\n  }\n\n  /** Closes the popover. */\n  public close(target?: HTMLElement): void {\n    if (this.state !== 'opened' && this.state !== 'opening') {\n      return;\n    }\n\n    this._popoverCloseElement = target;\n    if (!this.dispatchBeforeCloseEvent({ closeTarget: target ?? null })) {\n      return;\n    }\n\n    this.state = 'closing';\n    this.inert = true;\n    this._triggerElement?.setAttribute('aria-expanded', 'false');\n\n    // If the animation duration is zero, the animationend event is not always fired reliably.\n    // In this case we directly set the `closed` state.\n    if (this._isZeroAnimationDuration()) {\n      this._handleClosing();\n    }\n  }\n\n  private _isZeroAnimationDuration(): boolean {\n    return isZeroAnimationDuration(this, '--sbb-popover-animation-duration');\n  }\n\n  private _handleClosing(): void {\n    this.state = 'closed';\n    this.hidePopover?.();\n\n    this.overlay?.firstElementChild?.scrollTo(0, 0);\n    this.removeAttribute('tabindex');\n\n    if (!this._skipCloseFocus) {\n      const elementToFocus = this._nextFocusedElement || this._triggerElement;\n\n      // To enable focusing other element than the trigger, we need to call focus() a second time.\n      elementToFocus?.focus();\n    }\n\n    this._escapableOverlayController.disconnect();\n    this._openStateController?.abort();\n    this._focusTrapController.enabled = false;\n    this.dispatchCloseEvent({ closeTarget: this._popoverCloseElement ?? null });\n  }\n\n  private _handleOpening(): void {\n    this.state = 'opened';\n    this.inert = false;\n    this._setPopoverFocus();\n    this._focusTrapController.enabled = true;\n    this.dispatchOpenEvent();\n  }\n\n  public override connectedCallback(): void {\n    this.popover = 'manual';\n    super.connectedCallback();\n    this.id ||= `sbb-popover-${++nextId}`;\n    this.state = 'closed';\n    popoversRef.add(this);\n    if (this.hasUpdated) {\n      this._configureTrigger();\n    }\n  }\n\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n  ): void {\n    super.requestUpdate(name, oldValue, options);\n\n    // Checking for hoverTrigger is a special case, as only the SbbPopoverElement\n    // subclass has this property.\n    if (!isServer && (!name || name === 'trigger' || name === 'hoverTrigger') && this.hasUpdated) {\n      this._configureTrigger();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._configureTrigger();\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._triggerElement = null;\n    this._triggerAbortController?.abort();\n    this._openStateController?.abort();\n    popoversRef.delete(this);\n    if (this._blurTimeout) {\n      clearTimeout(this._blurTimeout);\n    }\n  }\n\n  // Check if the trigger is valid and attach click event listeners.\n  private _configureTrigger(): void {\n    if (isServer) {\n      return;\n    } else if (this.hydrationRequired) {\n      this.hydrationComplete.then(() => this._configureTrigger());\n      return;\n    }\n\n    this.configureTrigger(this._triggerElement ?? null);\n  }\n\n  protected configureTrigger(_oldTrigger: HTMLElement | null): void {\n    this._triggerAbortController?.abort();\n    removeAriaOverlayTriggerAttributes(this._triggerElement);\n    this._triggerElement = this.trigger;\n\n    if (!this._triggerElement) {\n      return;\n    }\n\n    setAriaOverlayTriggerAttributes(this._triggerElement, 'dialog', this.id, this.state);\n\n    this._triggerAbortController = new AbortController();\n    this.registerTriggerListeners(this._triggerAbortController.signal);\n  }\n\n  protected registerTriggerListeners(signal: AbortSignal): void {\n    this._triggerElement!.addEventListener('click', () => this.open(), { signal });\n  }\n\n  private _attachWindowEvents(): void {\n    this._openStateController = new AbortController();\n    document.addEventListener('scroll', () => this._setPopoverPosition(), {\n      passive: true,\n      signal: this._openStateController.signal,\n      // Without capture, other scroll contexts would not bubble to this event listener.\n      // Capture allows us to react to all scroll contexts in this DOM.\n      capture: true,\n    });\n    window.addEventListener('resize', () => this._setPopoverPosition(), {\n      passive: true,\n      signal: this._openStateController.signal,\n    });\n    // Close popover on backdrop click\n    window.addEventListener('pointerdown', this._pointerDownListener, {\n      signal: this._openStateController.signal,\n    });\n    window.addEventListener('pointerup', this._closeOnBackdropClick, {\n      signal: this._openStateController.signal,\n    });\n  }\n\n  // Close the popover on click of any element that has the 'sbb-popover-close' attribute.\n  private _closeOnSbbPopoverCloseClick(event: Event): void {\n    const closeElement = composedPathHasAttribute(event, 'sbb-popover-close', this);\n\n    if (closeElement && !closeElement.hasAttribute('disabled')) {\n      clearTimeout(this.closeTimeout);\n      this.close(closeElement);\n    }\n  }\n\n  // Check if the pointerdown event target is triggered on the popover.\n  private _pointerDownListener = (event: PointerEvent): void => {\n    this._isPointerDownEventOnPopover = isEventOnElement(this.overlay!, event);\n  };\n\n  // Close popover on backdrop click.\n  private _closeOnBackdropClick = (event: PointerEvent): void => {\n    const composedPath = event.composedPath();\n    if (\n      !this._isPointerDownEventOnPopover &&\n      !isEventOnElement(this.overlay!, event) &&\n      (!this.trigger || !composedPath.includes(this.trigger))\n    ) {\n      this._nextFocusedElement = composedPath\n        .filter((el) => el instanceof window.HTMLElement)\n        .find((el) => (el as HTMLElement).matches(IS_FOCUSABLE_QUERY)) as HTMLElement;\n      clearTimeout(this.closeTimeout);\n      this.close();\n    }\n  };\n\n  // Set popover position (x, y) to '0' once the popover is closed and the transition ended to prevent the\n  // viewport from overflowing. And set the focus to the first focusable element once the popover is open.\n  // In rare cases it can be that the animationEnd event is triggered twice.\n  // To avoid entering a corrupt state, exit when state is not expected.\n  private _onPopoverAnimationEnd(event: AnimationEvent): void {\n    if (event.animationName === 'open' && this.state === 'opening') {\n      this._handleOpening();\n    } else if (event.animationName === 'close' && this.state === 'closing') {\n      this._handleClosing();\n    }\n  }\n\n  // Set focus on the first focusable element.\n  private _setPopoverFocus(): void {\n    const focused = this._focusTrapController.focusInitialElement();\n\n    if (!focused && this._openStateController) {\n      this.setAttribute('tabindex', '0');\n      this.focus();\n\n      // When a blur occurs, we know that the popover has to be closed,\n      // because there are no interactive elements inside the popover.\n      // When a window/tab change occurs, a blur event is also fired. However, when the current window/tab\n      // becomes active again, it focuses once again the popover.\n      // Therefore, we cannot listen to the blur event only once.\n      // To prevent accidentally closing the popover, we need to check for the window/tab state.\n      // We can achieve this by using visibilityState, which only works with setTimeout().\n      this.addEventListener(\n        'blur',\n        (e: FocusEvent): void => {\n          this._blurTimeout = setTimeout(() => {\n            if (document.visibilityState !== 'hidden') {\n              this.removeAttribute('tabindex');\n\n              // In Safari on iOS it can occur, that a blur event triggers on the popover\n              // although the focus remains inside the popover.\n              // Therefore, we need to stop the closing if the relatedTarget is contained in the popover or it is the trigger.\n              if (this.contains(e.relatedTarget as Node) || e.relatedTarget === this.trigger) {\n                return;\n              }\n\n              if (this.state === 'opened' || this.state === 'opening') {\n                this._skipCloseFocus = true;\n              }\n              this.close();\n            }\n          });\n        },\n        {\n          signal: this._openStateController.signal,\n        },\n      );\n    }\n  }\n\n  private _setPopoverPosition(): void {\n    if (!this.overlay || !this._triggerElement) {\n      return;\n    }\n\n    const popoverPosition = getElementPosition(\n      this.overlay,\n      this._triggerElement,\n      this.shadowRoot!.querySelector('.sbb-popover__container')!,\n      {\n        verticalOffset: VERTICAL_OFFSET,\n        horizontalOffset: HORIZONTAL_OFFSET,\n        centered: true,\n        responsiveHeight: true,\n      },\n    );\n    const verticalPosition = popoverPosition.alignment.vertical;\n    for (const position of ['above', 'below']) {\n      this.toggleState(`position-${position}`, position === verticalPosition);\n    }\n\n    const arrowXPosition =\n      this._triggerElement.getBoundingClientRect().left -\n      popoverPosition.left +\n      this._triggerElement.clientWidth / 2 -\n      8; // half the size of the popover arrow\n\n    this.style.setProperty('--_sbb-popover-position-x', `${popoverPosition.left}px`);\n    this.style.setProperty('--_sbb-popover-position-y', `${popoverPosition.top}px`);\n    this.style.setProperty('--_sbb-popover-arrow-position-x', `${arrowXPosition}px`);\n    this.style.setProperty('--_sbb-popover-max-height', popoverPosition.maxHeight);\n  }\n\n  protected abstract renderContent(): TemplateResult;\n\n  protected override dispatchBeforeCloseEvent(detail?: {\n    closeTarget: HTMLElement | null;\n  }): boolean {\n    /**\n     * @type {CustomEvent<{ closeTarget: HTMLElement | null }>}\n     * Emits whenever the component begins the closing transition. Can be canceled.\n     */\n    return this.dispatchEvent(\n      new CustomEvent<{ closeTarget: HTMLElement | null }>('beforeclose', {\n        detail,\n        cancelable: true,\n      }),\n    );\n  }\n\n  protected override dispatchCloseEvent(detail?: { closeTarget: HTMLElement | null }): boolean {\n    /**\n     * @type {CustomEvent<{ closeTarget: HTMLElement | null }>}\n     * Emits whenever the component is closed.\n     */\n    return this.dispatchEvent(\n      new CustomEvent<{ closeTarget: HTMLElement | null }>('close', { detail }),\n    );\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-popover__container\">\n        <div\n          @animationend=${this._onPopoverAnimationEnd}\n          class=\"sbb-popover\"\n          role=\"tooltip\"\n          ${ref((el?: Element) => (this.overlay = el as HTMLDivElement))}\n        >\n          <div\n            @click=${(event: Event) => this._closeOnSbbPopoverCloseClick(event)}\n            class=\"sbb-popover__content\"\n          >\n            ${this.renderContent()}\n          </div>\n        </div>\n      </div>\n    `;\n  }\n}\n\n/**\n * It displays contextual information within a popover.\n *\n * @slot - Use the unnamed slot to add content into the popover.\n * @cssprop [--sbb-popover-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n */\nexport class SbbPopoverElement extends SbbPopoverBaseElement {\n  public static override readonly elementName: string = 'sbb-popover';\n  /** Whether the close button should be hidden. */\n  @forceType()\n  @property({ attribute: 'hide-close-button', type: Boolean, reflect: true })\n  public accessor hideCloseButton: boolean = false;\n\n  /** Whether the popover should be triggered on hover. */\n  @forceType()\n  @property({ attribute: 'hover-trigger', type: Boolean })\n  public accessor hoverTrigger: boolean = false;\n\n  /**\n   * Open the popover after a given delay in milliseconds.\n   * Global configuration is used as default, if not set.\n   *\n   * @default 0\n   */\n  @property({ attribute: 'open-delay', type: Number })\n  public set openDelay(value: number) {\n    this._openDelay = +value;\n  }\n  public get openDelay(): number {\n    return this._openDelay ?? readConfig().popover?.openDelay ?? 0;\n  }\n  private _openDelay?: number;\n\n  /**\n   * Close the popover after a given delay in milliseconds.\n   * Global configuration is used as default, if not set.\n   *\n   * @default 0\n   */\n  @property({ attribute: 'close-delay', type: Number })\n  public set closeDelay(value: number) {\n    this._closeDelay = +value;\n  }\n  public get closeDelay(): number {\n    return this._closeDelay ?? readConfig().popover?.closeDelay ?? 0;\n  }\n  private _closeDelay?: number;\n\n  /** This will be forwarded as aria-label to the close button element. */\n  @forceType()\n  @property({ attribute: 'accessibility-close-label' })\n  public accessor accessibilityCloseLabel: string = '';\n\n  private _hoverTrigger = false;\n  private _openTimeout?: ReturnType<typeof setTimeout>;\n  private _language = new SbbLanguageController(this);\n  private _overlayAbortController: AbortController | null = null;\n\n  protected override configureTrigger(oldTrigger: HTMLElement | null): void {\n    // Check whether the trigger can be hovered. Some devices might interpret the media query (hover: hover) differently,\n    // and not respect the fallback mechanism on the click. Therefore, the following is preferred to identify\n    // all non-touchscreen devices.\n    const hoverTrigger = this.hoverTrigger && !pointerCoarse;\n\n    if (this.trigger === oldTrigger && hoverTrigger === this._hoverTrigger) {\n      return;\n    }\n\n    if (this._hoverTrigger !== hoverTrigger) {\n      this._hoverTrigger = hoverTrigger;\n      this.toggleState('hover-trigger', this._hoverTrigger);\n      this._registerOverlayListeners();\n    }\n\n    super.configureTrigger(oldTrigger);\n  }\n\n  private _registerOverlayListeners(): void {\n    this._overlayAbortController?.abort();\n\n    if (this._hoverTrigger) {\n      this._overlayAbortController = new AbortController();\n      this.overlay?.addEventListener('mouseenter', () => this._onOverlayMouseEnter(), {\n        signal: this._overlayAbortController.signal,\n      });\n      this.overlay?.addEventListener('mouseleave', () => this._onOverlayMouseLeave(), {\n        signal: this._overlayAbortController.signal,\n      });\n    }\n  }\n\n  protected override registerTriggerListeners(signal: AbortSignal): void {\n    if (this._hoverTrigger && this.trigger) {\n      this.trigger.addEventListener('mouseenter', this._onTriggerMouseEnter, { signal });\n      this.trigger.addEventListener('mouseleave', this._onTriggerMouseLeave, { signal });\n      this.trigger.addEventListener(\n        'keydown',\n        (evt: KeyboardEvent) => {\n          if (evt.code === 'Space' || evt.code === 'Enter') {\n            this.open();\n          }\n        },\n        { signal },\n      );\n      this.trigger.addEventListener(\n        'mousedown',\n        (evt: MouseEvent) => {\n          // Without this check, NVDA can't open the popover on keyboard interaction.\n          if (isFakeMousedownFromScreenReader(evt)) {\n            this.open();\n          }\n        },\n        { signal },\n      );\n    } else {\n      super.registerTriggerListeners(signal);\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    this._registerOverlayListeners();\n  }\n\n  public override open(): void {\n    super.open();\n\n    if (this.hoverTrigger && this.trigger) {\n      ɵstateController(this.trigger).add('force-hover');\n    }\n  }\n\n  public override close(): void {\n    super.close();\n\n    ɵstateController(this.trigger)?.delete('force-hover');\n  }\n\n  private _onTriggerMouseEnter = (): void => {\n    if (this.state === 'closed' || this.state === 'closing') {\n      this._openTimeout = setTimeout(() => {\n        // If the trigger is focused by keyboard and hovered with the mouse, the outline would be visible.\n        // So we reset the input modality to hide the outline.\n        sbbInputModalityDetector.reset();\n        this.open();\n      }, this.openDelay);\n    } else {\n      clearTimeout(this.closeTimeout);\n    }\n  };\n\n  private _onTriggerMouseLeave = (): void => {\n    if (this.state === 'opened' || this.state === 'opening') {\n      this.closeTimeout = setTimeout(() => this.close(), this.closeDelay);\n    } else {\n      clearTimeout(this._openTimeout);\n    }\n  };\n\n  private _onOverlayMouseEnter = (): void => {\n    if (this.state !== 'opening') {\n      clearTimeout(this.closeTimeout);\n    }\n  };\n\n  private _onOverlayMouseLeave = (): void => {\n    if (this.state !== 'opening') {\n      this.closeTimeout = setTimeout(() => this.close(), this.closeDelay);\n    }\n  };\n\n  protected override renderContent(): TemplateResult {\n    const closeButton = html`\n      <sbb-secondary-button\n        aria-label=${this.accessibilityCloseLabel || i18nClosePopover[this._language.current]}\n        size=\"s\"\n        type=\"button\"\n        icon-name=\"cross-small\"\n        sbb-popover-close\n      ></sbb-secondary-button>\n    `;\n\n    return html`\n      ${!this.hideCloseButton && !this._hoverTrigger ? closeButton : nothing}\n      <span class=\"sbb-popover__scrollable-content\">\n        <slot>No content</slot>\n      </span>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-popover': SbbPopoverElement;\n  }\n}\n"],"mappings":"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"}