@sbb-esta/lyne-elements 5.0.0-next.2 → 5.0.0

package/development/popover-base-BcIAVXWF.js

@@ -0,0 +1,288 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { IS_FOCUSABLE_QUERY, SbbEscapableOverlayController, SbbFocusTrapController, SbbOpenCloseBaseElement, getElementPosition, idReference, isEventOnElement, isZeroAnimationDuration, popoverResetStyles, removeAriaOverlayTriggerProperties, setAriaOverlayTriggerProperties } from "./core.js";
+import { ResizeController } from "@lit-labs/observers/resize-controller.js";
+import { ref } from "lit/directives/ref.js";
+//#region src/elements/popover/popover-base/popover-base.scss?inline
+var popover_base_default = ":host {\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-default);\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-translate: 0 var(--sbb-spacing-fixed-2x);\n  --_sbb-popover-box-shadow: var(--sbb-box-shadow-level-9-hard);\n  outline: none !important;\n  display: none;\n}\n\n:host(:is(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]), :is(:state(state-closing),[state--state-closing]))) {\n  --_sbb-popover-inset: 0;\n  display: block;\n}\n\n:host(:is(:state(position-above),[state--position-above])) {\n  --_sbb-popover-translate: 0 calc(var(--sbb-spacing-fixed-2x) * -1);\n}\n\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% - var(--sbb-popover-arrow-size) / 2);\n  background-color: var(--sbb-popover-background);\n  border-radius: var(--sbb-border-radius-2x) 0;\n  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  display: none;\n  position: var(--sbb-popover-position, absolute);\n  top: var(--_sbb-popover-position-y, 0);\n  bottom: unset;\n  left: var(--_sbb-popover-position-x, 0);\n  right: unset;\n  background-color: var(--sbb-popover-background);\n  max-width: var(--sbb-popover-max-width);\n  width: max-content;\n  padding: 0;\n  box-shadow: var(--_sbb-popover-box-shadow);\n  border: none;\n  border-radius: var(--sbb-popover-border-radius);\n  outline: none;\n  pointer-events: all;\n}\n:host(:focus-visible) .sbb-popover {\n  outline-offset: var(--sbb-focus-outline-offset);\n  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);\n}\n: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 {\n  display: block;\n  animation-name: open;\n  animation-duration: var(--sbb-popover-animation-duration);\n  animation-timing-function: var(--sbb-popover-animation-easing);\n}\n:host(:is(:state(state-closing),[state--state-closing])) .sbb-popover {\n  pointer-events: none;\n  animation-name: close;\n  animation-duration: var(--sbb-popover-animation-duration);\n  animation-timing-function: var(--sbb-popover-animation-easing);\n}\n.sbb-popover::after {\n  z-index: -1;\n  box-shadow: var(--_sbb-popover-box-shadow);\n}\n@media (forced-colors: active) {\n  .sbb-popover::after {\n    outline: var(--sbb-border-width-1x) solid CanvasText;\n  }\n}\n:host(:is(:state(position-above),[state--position-above])) .sbb-popover::after {\n  top: calc(100% - var(--sbb-popover-arrow-size) / 2);\n}\n@media (forced-colors: active) {\n  .sbb-popover {\n    outline: var(--sbb-border-width-1x) solid CanvasText;\n  }\n}\n.sbb-popover::before {\n  content: \"\";\n  display: block;\n  position: absolute;\n  inset: 0;\n  z-index: -1;\n  background-color: transparent;\n}\n:host(:is(:state(position-below),[state--position-below])) .sbb-popover::before {\n  inset-block-start: calc(-1 * var(--sbb-spacing-fixed-6x));\n}\n:host(:is(:state(position-above),[state--position-above])) .sbb-popover::before {\n  inset-block-end: calc(-1 * var(--sbb-spacing-fixed-6x));\n}\n\n.sbb-popover__content {\n  border-radius: var(--sbb-popover-border-radius);\n  padding: var(--sbb-popover-padding);\n  outline: none;\n  background-color: var(--sbb-popover-background);\n}\n.sbb-popover__content::before {\n  clip-path: polygon(100% 0, 0% 0%, 0% 100%);\n}\n:host(:is(:state(position-above),[state--position-above])) .sbb-popover__content::before {\n  top: calc(100% - var(--sbb-popover-arrow-size) / 2);\n  clip-path: polygon(100% 0, 100% 100%, 0% 100%);\n}\n\n@keyframes open {\n  from {\n    opacity: 0;\n    translate: var(--_sbb-popover-translate);\n  }\n  to {\n    opacity: 1;\n    translate: 0;\n  }\n}\n@keyframes close {\n  from {\n    opacity: 1;\n    translate: 0;\n  }\n  to {\n    opacity: 0;\n    translate: var(--_sbb-popover-translate);\n  }\n}";
+//#endregion
+//#region src/elements/popover/popover-base/popover-base.ts
+var VERTICAL_OFFSET = 16;
+var HORIZONTAL_OFFSET = 32;
+var popoversRef = /* @__PURE__ */ new Set();
+var SbbPopoverCloseEvent = class extends Event {
+	get closeTarget() {
+		return this._closeTarget;
+	}
+	constructor(type, { closeTarget, cancelable }) {
+		super(type, { cancelable });
+		this._closeTarget = closeTarget;
+	}
+};
+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._resizeController = new ResizeController(this, {
+				target: null,
+				callback: () => this._setPopoverPosition()
+			});
+			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 = [popoverResetStyles, unsafeCSS(popover_base_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._nextFocusedElement = void 0;
+			this._skipCloseFocus = false;
+			if (this._triggerElement) this._triggerElement.ariaExpanded = "true";
+			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;
+			if (this._triggerElement) this._triggerElement.ariaExpanded = "false";
+			if (this._isZeroAnimationDuration()) this._handleClosing();
+		}
+		_isZeroAnimationDuration() {
+			return isZeroAnimationDuration(this, "--sbb-popover-animation-duration");
+		}
+		_handleClosing() {
+			this.state = "closed";
+			this.hidePopover?.();
+			if (this.overlay) {
+				this._resizeController.unobserve(this.overlay);
+				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;
+			if (this.overlay) this._resizeController.observe(this.overlay);
+			this.dispatchOpenEvent();
+		}
+		connectedCallback() {
+			this.popover = "manual";
+			super.connectedCallback();
+			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();
+			removeAriaOverlayTriggerProperties(this._triggerElement);
+			this._triggerElement = this.trigger;
+			if (!this._triggerElement) return;
+			setAriaOverlayTriggerProperties(this, this._triggerElement, "dialog", 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 = event.composedPath().find((el, i, a) => el instanceof HTMLElement && i < a.indexOf(this) && (el.hasAttribute("sbb-popover-close") || el.localName === "sbb-popover-close-button") && !el.hasAttribute("disabled"));
+			if (closeElement) {
+				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) {
+			const closeTarget = detail?.closeTarget ?? null;
+			/**
+			* @type {SbbPopoverCloseEvent}
+			* Emits whenever the component begins the closing transition. Can be canceled.
+			*/
+			return this.dispatchEvent(new SbbPopoverCloseEvent("beforeclose", {
+				closeTarget,
+				cancelable: true
+			}));
+		}
+		dispatchCloseEvent(detail) {
+			const closeTarget = detail?.closeTarget ?? null;
+			/**
+			* @type {SbbPopoverCloseEvent}
+			* Emits whenever the component is closed.
+			*/
+			return this.dispatchEvent(new SbbPopoverCloseEvent("close", {
+				closeTarget,
+				cancelable: false
+			}));
+		}
+		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>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbPopoverCloseEvent as n, SbbPopoverBaseElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"popover-base-BcIAVXWF.js","names":[],"sources":["../../../src/elements/popover/popover-base/popover-base.scss?inline","../../../src/elements/popover/popover-base/popover-base.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-translate: 0 var(--sbb-spacing-fixed-2x);\n  --_sbb-popover-box-shadow: var(--sbb-box-shadow-level-9-hard);\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-translate: 0 calc(var(--sbb-spacing-fixed-2x) * -1);\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  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  display: none;\n  position: var(--sbb-popover-position, absolute);\n  top: var(--_sbb-popover-position-y, 0);\n  bottom: unset;\n  left: var(--_sbb-popover-position-x, 0);\n  right: unset;\n  background-color: var(--sbb-popover-background);\n  max-width: var(--sbb-popover-max-width);\n  width: max-content;\n  padding: 0;\n  box-shadow: var(--_sbb-popover-box-shadow);\n  border: none;\n  border-radius: var(--sbb-popover-border-radius);\n  outline: none;\n  pointer-events: all;\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-popover-box-shadow);\n\n    @media (forced-colors: active) {\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  @media (forced-colors: active) {\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  border-radius: var(--sbb-popover-border-radius);\n  padding: var(--sbb-popover-padding);\n  outline: none;\n  background-color: var(--sbb-popover-background);\n\n  &::before {\n    // Clip the arrow that it doesn't overflow content\n    clip-path: polygon(100% 0, 0% 0%, 0% 100%);\n  }\n\n  :host(:state(position-above)) & {\n    &::before {\n      top: calc(100% - calc(var(--sbb-popover-arrow-size) / 2));\n\n      // Clip the arrow that it doesn't overflow content\n      clip-path: polygon(100% 0, 100% 100%, 0% 100%);\n    }\n  }\n}\n\n@keyframes open {\n  from {\n    opacity: 0;\n    translate: var(--_sbb-popover-translate);\n  }\n\n  to {\n    opacity: 1;\n    translate: 0;\n  }\n}\n\n@keyframes close {\n  from {\n    opacity: 1;\n    translate: 0;\n  }\n\n  to {\n    opacity: 0;\n    translate: var(--_sbb-popover-translate);\n  }\n}\n","import { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  isServer,\n  type PropertyDeclaration,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport {\n  getElementPosition,\n  idReference,\n  IS_FOCUSABLE_QUERY,\n  isEventOnElement,\n  isZeroAnimationDuration,\n  popoverResetStyles,\n  removeAriaOverlayTriggerProperties,\n  SbbEscapableOverlayController,\n  SbbFocusTrapController,\n  SbbOpenCloseBaseElement,\n  setAriaOverlayTriggerProperties,\n} from '../../core.ts';\n\nimport style from './popover-base.scss?inline';\n\nconst VERTICAL_OFFSET = 16;\nconst HORIZONTAL_OFFSET = 32;\n\nconst popoversRef = new Set<SbbPopoverBaseElement>();\n\nexport class SbbPopoverCloseEvent extends Event {\n  private readonly _closeTarget: HTMLElement | null;\n\n  public get closeTarget(): HTMLElement | null {\n    return this._closeTarget;\n  }\n\n  public constructor(\n    type: string,\n    { closeTarget, cancelable }: Pick<Event, 'cancelable'> & { closeTarget: HTMLElement | null },\n  ) {\n    super(type, { cancelable });\n    this._closeTarget = closeTarget;\n  }\n}\n\nexport abstract class SbbPopoverBaseElement extends SbbOpenCloseBaseElement {\n  public static override styles: CSSResultGroup = [popoverResetStyles, unsafeCSS(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 _resizeController = new ResizeController(this, {\n    target: null,\n    callback: () => this._setPopoverPosition(),\n  });\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._nextFocusedElement = undefined;\n    this._skipCloseFocus = false;\n    if (this._triggerElement) {\n      this._triggerElement.ariaExpanded = 'true';\n    }\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    if (this._triggerElement) {\n      this._triggerElement.ariaExpanded = 'false';\n    }\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    if (this.overlay) {\n      this._resizeController.unobserve(this.overlay);\n      this.overlay.firstElementChild?.scrollTo(0, 0);\n    }\n\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    if (this.overlay) {\n      this._resizeController.observe(this.overlay);\n    }\n    this.dispatchOpenEvent();\n  }\n\n  public override connectedCallback(): void {\n    this.popover = 'manual';\n    super.connectedCallback();\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\n    removeAriaOverlayTriggerProperties(this._triggerElement);\n    this._triggerElement = this.trigger;\n\n    if (!this._triggerElement) {\n      return;\n    }\n\n    setAriaOverlayTriggerProperties(this, this._triggerElement, 'dialog', 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 = event\n      .composedPath()\n      .find(\n        (el, i, a): el is HTMLElement =>\n          el instanceof HTMLElement &&\n          i < a.indexOf(this) &&\n          (el.hasAttribute('sbb-popover-close') || el.localName === 'sbb-popover-close-button') &&\n          !el.hasAttribute('disabled'),\n      );\n    if (closeElement) {\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    const closeTarget = detail?.closeTarget ?? null;\n    /**\n     * @type {SbbPopoverCloseEvent}\n     * Emits whenever the component begins the closing transition. Can be canceled.\n     */\n    return this.dispatchEvent(\n      new SbbPopoverCloseEvent('beforeclose', { closeTarget, cancelable: true }),\n    );\n  }\n\n  protected override dispatchCloseEvent(detail?: { closeTarget: HTMLElement | null }): boolean {\n    const closeTarget = detail?.closeTarget ?? null;\n    /**\n     * @type {SbbPopoverCloseEvent}\n     * Emits whenever the component is closed.\n     */\n    return this.dispatchEvent(\n      new SbbPopoverCloseEvent('close', { closeTarget, cancelable: false }),\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"],"mappings":"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"}

package/development/popover.component-CMR0eV2t.js

@@ -0,0 +1,233 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, unsafeCSS } from "lit";
+import { property, state } from "lit/decorators.js";
+import { SbbMediaQueryPointerCoarse, forceType, isFakeMousedownFromScreenReader, readConfig, sbbInputModalityDetector, scrollbarStyles, ɵstateController } from "./core.js";
+import { SbbPopoverBaseElement } from "./popover/popover-base/popover-base.js";
+//#region src/elements/popover/popover/popover.scss?inline
+var popover_default = ":host {\n  --_sbb-popover-half-padding: calc(0.5 * var(--sbb-popover-padding));\n  position: relative;\n}\n\n:host(:is(:state(has-close-button),[state--has-close-button])) {\n  --_sbb-popover-close-button-min-height: calc(\n    var(--sbb-button-min-height-size-s) + 2 * var(--sbb-popover-padding)\n  );\n  --_sbb-popover-close-button-min-width: calc(\n    var(--_sbb-popover-close-button-min-height) - var(--_sbb-popover-half-padding)\n  );\n}\n\n.sbb-popover__content {\n  padding-block: var(--_sbb-popover-half-padding);\n  padding-inline: var(--_sbb-popover-half-padding) var(--_sbb-popover-close-button-min-width, var(--_sbb-popover-half-padding));\n  min-height: var(--_sbb-popover-close-button-min-height);\n}\n\n.sbb-popover__scrollable-content {\n  display: block;\n  padding-inline: var(--_sbb-popover-half-padding);\n  padding-block: var(--_sbb-popover-half-padding);\n  max-height: calc(var(--_sbb-popover-max-height) - var(--sbb-spacing-fixed-1x));\n  overflow: auto;\n}\n\n::slotted(sbb-popover-close-button) {\n  position: absolute;\n  inset: var(--sbb-popover-padding) var(--sbb-popover-padding) auto auto;\n}";
+//#endregion
+//#region src/elements/popover/popover/popover.component.ts
+var pointerCoarse = isServer ? false : matchMedia(SbbMediaQueryPointerCoarse).matches;
+/**
+* It displays contextual information within a popover.
+*
+* @slot - Use the unnamed slot to add the `sbb-popover-close-button` and 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 _hoverTrigger_decorators;
+	let _hoverTrigger_initializers = [];
+	let _hoverTrigger_extraInitializers = [];
+	let _set_openDelay_decorators;
+	let _set_closeDelay_decorators;
+	let __hoverTrigger_decorators;
+	let __hoverTrigger_initializers = [];
+	let __hoverTrigger_extraInitializers = [];
+	return class SbbPopoverElement extends _classSuper {
+		constructor() {
+			super(...arguments);
+			this.#hoverTrigger_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _hoverTrigger_initializers, false));
+			this._openDelay = __runInitializers(this, _hoverTrigger_extraInitializers);
+			this.#_hoverTrigger_accessor_storage = __runInitializers(this, __hoverTrigger_initializers, false);
+			this._openTimeout = __runInitializers(this, __hoverTrigger_extraInitializers);
+			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;
+			_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
+			})];
+			__hoverTrigger_decorators = [state()];
+			__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, __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);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-popover";
+		}
+		static {
+			this.styles = [scrollbarStyles, unsafeCSS(popover_default)];
+		}
+		#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;
+		}
+		#_hoverTrigger_accessor_storage;
+		get _hoverTrigger() {
+			return this.#_hoverTrigger_accessor_storage;
+		}
+		set _hoverTrigger(value) {
+			this.#_hoverTrigger_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() {
+			return html`
+      <span class="sbb-popover__scrollable-content sbb-scrollbar">
+        <slot
+          @slotchange=${() => this.toggleState("has-close-button", !!this.querySelector("sbb-popover-close-button"))}
+        ></slot>
+      </span>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbPopoverElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"popover.component-CMR0eV2t.js","names":[],"sources":["../../../src/elements/popover/popover/popover.scss?inline","../../../src/elements/popover/popover/popover.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --_sbb-popover-half-padding: calc(0.5 * var(--sbb-popover-padding));\n\n  position: relative;\n}\n\n:host(:state(has-close-button)) {\n  --_sbb-popover-close-button-min-height: calc(\n    var(--sbb-button-min-height-size-s) + 2 * var(--sbb-popover-padding)\n  );\n  --_sbb-popover-close-button-min-width: calc(\n    var(--_sbb-popover-close-button-min-height) - var(--_sbb-popover-half-padding)\n  );\n}\n\n.sbb-popover__content {\n  // We use half of the padding on the container and half on the scroll context.\n  // With that, the focus outline is not cut and the scrollable context doesn't touch the borders.\n  padding-block: var(--_sbb-popover-half-padding);\n  padding-inline: var(--_sbb-popover-half-padding)\n    var(--_sbb-popover-close-button-min-width, var(--_sbb-popover-half-padding));\n  min-height: var(--_sbb-popover-close-button-min-height);\n}\n\n.sbb-popover__scrollable-content {\n  display: block;\n\n  // We use half of the padding on the container and half on the scroll context.\n  // With that, the focus outline is not cut and the scrollable context doesn't touch the borders.\n  padding-inline: var(--_sbb-popover-half-padding);\n  padding-block: var(--_sbb-popover-half-padding);\n  max-height: calc(var(--_sbb-popover-max-height) - var(--sbb-spacing-fixed-1x));\n  overflow: auto;\n}\n\n::slotted(sbb-popover-close-button) {\n  position: absolute;\n  inset: var(--sbb-popover-padding) var(--sbb-popover-padding) auto auto;\n}\n","import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport {\n  forceType,\n  isFakeMousedownFromScreenReader,\n  readConfig,\n  sbbInputModalityDetector,\n  SbbMediaQueryPointerCoarse,\n  scrollbarStyles,\n  ɵstateController,\n} from '../../core.ts';\nimport { SbbPopoverBaseElement } from '../popover-base/popover-base.ts';\n\nimport style from './popover.scss?inline';\n\nconst pointerCoarse = isServer ? false : matchMedia(SbbMediaQueryPointerCoarse).matches;\n\n/**\n * It displays contextual information within a popover.\n *\n * @slot - Use the unnamed slot to add the `sbb-popover-close-button` and 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  public static override styles: CSSResultGroup = [scrollbarStyles, unsafeCSS(style)];\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  @state() private accessor _hoverTrigger = false;\n  private _openTimeout?: ReturnType<typeof setTimeout>;\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    return html`\n      <span class=\"sbb-popover__scrollable-content sbb-scrollbar\">\n        <slot\n          @slotchange=${() =>\n            this.toggleState('has-close-button', !!this.querySelector('sbb-popover-close-button'))}\n        ></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":";;;;;;;;;ACuBA,IAAM,gBAAgB,WAAW,QAAQ,WAAW,0BAA0B,EAAE;;;;;;;;;IAUnE,2BAAiB;mBAAS;;;;;;;;;;cAA1B,0BAA0B,YAAqB;;;GAO1C,KAAA,kCAPL,kBAAA,MAAA,0BAAA,GAAiB,kBAAA,MAAA,4BAOY,KAAK;GAerC,KAAA,aAAU,kBAAA,MAAA,+BAAA;GAiBQ,KAAA,kCAAA,kBAAA,MAAA,6BAAgB,KAAK;GACvC,KAAA,eAAY,kBAAA,MAAA,gCAAA;GACZ,KAAA,0BAAkD;GAmFlD,KAAA,6BAAkC;IACxC,IAAI,KAAK,UAAU,YAAY,KAAK,UAAU,WAC5C,KAAK,eAAe,iBAAgB;KAGlC,yBAAyB,MAAK;KAC9B,KAAK,KAAI;IACX,GAAG,KAAK,SAAS;SAEjB,aAAa,KAAK,YAAY;GAElC;GAEQ,KAAA,6BAAkC;IACxC,IAAI,KAAK,UAAU,YAAY,KAAK,UAAU,WAC5C,KAAK,eAAe,iBAAiB,KAAK,MAAK,GAAI,KAAK,UAAU;SAElE,aAAa,KAAK,YAAY;GAElC;GAEQ,KAAA,6BAAkC;IACxC,IAAI,KAAK,UAAU,WACjB,aAAa,KAAK,YAAY;GAElC;GAEQ,KAAA,6BAAkC;IACxC,IAAI,KAAK,UAAU,WACjB,KAAK,eAAe,iBAAiB,KAAK,MAAK,GAAI,KAAK,UAAU;GAEtE;EAYF;;;+BAlKG,UAAS,GACT,SAAS;IAAE,WAAW;IAAiB,MAAM;GAAO,CAAE,CAAC;gCASvD,SAAS;IAAE,WAAW;IAAc,MAAM;GAAM,CAAE,CAAC;iCAenD,SAAS;IAAE,WAAW;IAAe,MAAM;GAAM,CAAE,CAAC;gCASpD,MAAK,CAAE;GAhCR,aAAA,MAAA,MAAA,0BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,kBAAA;KAAA,MAAA,QAAA,IAAgB;KAAY,MAAA,KAAA,UAAA;MAAA,IAAZ,eAAY;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,4BAAA,+BAAA;GAS5B,aAAA,MAAA,MAAA,2BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,eAAA;KAAA,MAAA,KAAA,UAAA;MAAA,IAAW,YAAS;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,MAAA,0BAAA;GAepB,aAAA,MAAA,MAAA,4BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,gBAAA;KAAA,MAAA,KAAA,UAAA;MAAA,IAAW,aAAU;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,MAAA,0BAAA;GAQZ,aAAA,MAAA,MAAA,2BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,mBAAA;KAAA,MAAA,QAAA,IAAiB;KAAa,MAAA,KAAA,UAAA;MAAA,IAAb,gBAAa;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,6BAAA,gCAAA;;;;;;;;;GAtCP,KAAA,cAAsB;EAAc;;GAC7C,KAAA,SAAyB,CAAC,iBAAiB,UAAU,eAAK,CAAC;EAAE;EAKpF;;EAAA,IAAgB,eAAY;GAAA,OAAA,KAAA;EAAA;EAA5B,IAAgB,aAAY,OAAA;GAAA,KAAA,iCAAA;EAAA;;;;;;;EAS5B,IAAW,UAAU,OAAa;GAChC,KAAK,aAAa,CAAC;EACrB;EACA,IAAW,YAAS;GAClB,OAAO,KAAK,cAAc,WAAU,EAAG,SAAS,aAAa;EAC/D;;;;;;;EAUA,IAAW,WAAW,OAAa;GACjC,KAAK,cAAc,CAAC;EACtB;EACA,IAAW,aAAU;GACnB,OAAO,KAAK,eAAe,WAAU,EAAG,SAAS,cAAc;EACjE;EAGS;EAAA,IAAiB,gBAAa;GAAA,OAAA,KAAA;EAAA;EAA9B,IAAiB,cAAa,OAAA;GAAA,KAAA,kCAAA;EAAA;EAIpB,iBAAiB,YAA8B;GAIhE,MAAM,eAAe,KAAK,gBAAgB,CAAC;GAE3C,IAAI,KAAK,YAAY,cAAc,iBAAiB,KAAK,eACvD;GAGF,IAAI,KAAK,kBAAkB,cAAc;IACvC,KAAK,gBAAgB;IACrB,KAAK,YAAY,iBAAiB,KAAK,aAAa;IACpD,KAAK,0BAAyB;GAChC;GAEA,MAAM,iBAAiB,UAAU;EACnC;EAEQ,4BAAyB;GAC/B,KAAK,yBAAyB,MAAK;GAEnC,IAAI,KAAK,eAAe;IACtB,KAAK,0BAA0B,IAAI,gBAAe;IAClD,KAAK,SAAS,iBAAiB,oBAAoB,KAAK,qBAAoB,GAAI,EAC9E,QAAQ,KAAK,wBAAwB,OAAA,CACtC;IACD,KAAK,SAAS,iBAAiB,oBAAoB,KAAK,qBAAoB,GAAI,EAC9E,QAAQ,KAAK,wBAAwB,OAAA,CACtC;GACH;EACF;EAEmB,yBAAyB,QAAmB;GAC7D,IAAI,KAAK,iBAAiB,KAAK,SAAS;IACtC,KAAK,QAAQ,iBAAiB,cAAc,KAAK,sBAAsB,EAAE,OAAM,CAAE;IACjF,KAAK,QAAQ,iBAAiB,cAAc,KAAK,sBAAsB,EAAE,OAAM,CAAE;IACjF,KAAK,QAAQ,iBACX,YACC,QAAsB;KACrB,IAAI,IAAI,SAAS,WAAW,IAAI,SAAS,SACvC,KAAK,KAAI;IAEb,GACA,EAAE,OAAM,CAAE;IAEZ,KAAK,QAAQ,iBACX,cACC,QAAmB;KAElB,IAAI,gCAAgC,GAAG,GACrC,KAAK,KAAI;IAEb,GACA,EAAE,OAAM,CAAE;GAEd,OACE,MAAM,yBAAyB,MAAM;EAEzC;EAEmB,aAAa,mBAAuC;GACrE,MAAM,aAAa,iBAAiB;GAEpC,KAAK,0BAAyB;EAChC;EAEgB,OAAI;GAClB,MAAM,KAAI;GAEV,IAAI,KAAK,gBAAgB,KAAK,SAC5B,iBAAiB,KAAK,OAAO,EAAE,IAAI,aAAa;EAEpD;EAEgB,QAAK;GACnB,MAAM,MAAK;GAEX,iBAAiB,KAAK,OAAO,GAAG,OAAO,aAAa;EACtD;EAmCmB,gBAAa;GAC9B,OAAO,IAAI;;;8BAIH,KAAK,YAAY,oBAAoB,CAAC,CAAC,KAAK,cAAc,0BAA0B,CAAC,EAAA;;;;EAI/F"}

package/development/popover.js

@@ -1,9 +1,12 @@
-import { n as SbbPopoverElement, t as SbbPopoverBaseElement } from "./popover.component-Bvbf4NyI.js";
+import { n as SbbPopoverCloseEvent, t as SbbPopoverBaseElement } from "./popover-base-BcIAVXWF.js";
+import { t as SbbPopoverElement } from "./popover.component-CMR0eV2t.js";
+import { SbbPopoverCloseButtonElement } from "./popover/popover-close-button/popover-close-button.component.js";
 import "./popover.pure.js";
 //#region src/elements/popover.ts
 /** @entrypoint */
 SbbPopoverElement.define();
+SbbPopoverCloseButtonElement.define();
 //#endregion
-export { SbbPopoverBaseElement, SbbPopoverElement };
+export { SbbPopoverBaseElement, SbbPopoverCloseButtonElement, SbbPopoverCloseEvent, SbbPopoverElement };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvcG9wb3Zlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYlBvcG92ZXJFbGVtZW50IH0gZnJvbSAnLi9wb3BvdmVyLnB1cmUudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL3BvcG92ZXIucHVyZS50cyc7XG5cblNiYlBvcG92ZXJFbGVtZW50LmRlZmluZSgpO1xuIl0sIm1hcHBpbmdzIjoiOzs7O0FBS0Esa0JBQWtCLFFBQVEifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvcG9wb3Zlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYlBvcG92ZXJDbG9zZUJ1dHRvbkVsZW1lbnQsIFNiYlBvcG92ZXJFbGVtZW50IH0gZnJvbSAnLi9wb3BvdmVyLnB1cmUudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL3BvcG92ZXIucHVyZS50cyc7XG5cblNiYlBvcG92ZXJFbGVtZW50LmRlZmluZSgpO1xuU2JiUG9wb3ZlckNsb3NlQnV0dG9uRWxlbWVudC5kZWZpbmUoKTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBS0Esa0JBQWtCLE9BQU07QUFDeEIsNkJBQTZCLE9BQU0ifQ==

package/development/popover.pure.d.ts

@@ -1,3 +1,5 @@
 /** @entrypoint */
-export * from './popover/popover.component.ts';
+export * from './popover/popover-base/popover-base.ts';
+export * from './popover/popover/popover.component.ts';
+export * from './popover/popover-close-button/popover-close-button.component.ts';
 //# sourceMappingURL=popover.pure.d.ts.map