@sbb-esta/lyne-elements-dev 4.13.1-dev.1781017607 → 5.0.0-dev.1781073732

package/development/popover/popover-base/popover-base.d.ts

@@ -0,0 +1,61 @@
+import { CSSResultGroup, PropertyDeclaration, PropertyValues, TemplateResult } from 'lit';
+import { SbbOpenCloseBaseElement } from '../../core.ts';
+export declare class SbbPopoverCloseEvent extends Event {
+    private readonly _closeTarget;
+    get closeTarget(): HTMLElement | null;
+    constructor(type: string, { closeTarget, cancelable }: Pick<Event, 'cancelable'> & {
+        closeTarget: HTMLElement | null;
+    });
+}
+export declare abstract class SbbPopoverBaseElement extends SbbOpenCloseBaseElement {
+    static styles: CSSResultGroup;
+    /**
+     * The element that will trigger the popover overlay.
+     *
+     * For attribute usage, provide an id reference.
+     */
+    accessor trigger: HTMLElement | null;
+    private _nextFocusedElement?;
+    private _skipCloseFocus;
+    private _popoverCloseElement?;
+    private _isPointerDownEventOnPopover?;
+    private _triggerElement?;
+    private _triggerAbortController?;
+    private _openStateController?;
+    private _resizeController;
+    private _escapableOverlayController;
+    private _focusTrapController;
+    private _blurTimeout;
+    protected closeTimeout?: ReturnType<typeof setTimeout>;
+    protected overlay?: HTMLDivElement;
+    /** Opens the popover on trigger click. */
+    open(): void;
+    /** Closes the popover. */
+    close(target?: HTMLElement): void;
+    private _isZeroAnimationDuration;
+    private _handleClosing;
+    private _handleOpening;
+    connectedCallback(): void;
+    requestUpdate(name?: PropertyKey, oldValue?: unknown, options?: PropertyDeclaration): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    disconnectedCallback(): void;
+    private _configureTrigger;
+    protected configureTrigger(_oldTrigger: HTMLElement | null): void;
+    protected registerTriggerListeners(signal: AbortSignal): void;
+    private _attachWindowEvents;
+    private _closeOnSbbPopoverCloseClick;
+    private _pointerDownListener;
+    private _closeOnBackdropClick;
+    private _onPopoverAnimationEnd;
+    private _setPopoverFocus;
+    private _setPopoverPosition;
+    protected abstract renderContent(): TemplateResult;
+    protected dispatchBeforeCloseEvent(detail?: {
+        closeTarget: HTMLElement | null;
+    }): boolean;
+    protected dispatchCloseEvent(detail?: {
+        closeTarget: HTMLElement | null;
+    }): boolean;
+    protected render(): TemplateResult;
+}
+//# sourceMappingURL=popover-base.d.ts.map

package/development/popover/popover-base/popover-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popover-base.d.ts","sourceRoot":"","sources":["../../../../../src/elements/popover/popover-base/popover-base.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAIb,OAAO,EAUL,uBAAuB,EAExB,MAAM,eAAe,CAAC;AASvB,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAElD,IAAW,WAAW,IAAI,WAAW,GAAG,IAAI,CAE3C;gBAGC,IAAI,EAAE,MAAM,EACZ,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,GAAG;QAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAAA;KAAE;CAK/F;AAED,8BAAsB,qBAAsB,SAAQ,uBAAuB;IACzE,OAAuB,MAAM,EAAE,cAAc,CAA0C;IAEvF;;;;OAIG;IACH,SAEgB,OAAO,EAAE,WAAW,GAAG,IAAI,CAAQ;IAGnD,OAAO,CAAC,mBAAmB,CAAC,CAAc;IAC1C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,oBAAoB,CAAC,CAAc;IAC3C,OAAO,CAAC,4BAA4B,CAAC,CAAU;IAC/C,OAAO,CAAC,eAAe,CAAC,CAAqB;IAC7C,OAAO,CAAC,uBAAuB,CAAC,CAAkB;IAClD,OAAO,CAAC,oBAAoB,CAAC,CAAkB;IAC/C,OAAO,CAAC,iBAAiB,CAGtB;IACH,OAAO,CAAC,2BAA2B,CAA2C;IAC9E,OAAO,CAAC,oBAAoB,CAAoC;IAChE,OAAO,CAAC,YAAY,CAA8C;IAClE,SAAS,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;IACvD,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAEnC,0CAA0C;IACnC,IAAI,IAAI,IAAI;IAmCnB,0BAA0B;IACnB,KAAK,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI;IAuBxC,OAAO,CAAC,wBAAwB;IAIhC,OAAO,CAAC,cAAc;IAuBtB,OAAO,CAAC,cAAc;IAWN,iBAAiB,IAAI,IAAI;IAUzB,aAAa,CAC3B,IAAI,CAAC,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI;cAUY,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAK9D,oBAAoB,IAAI,IAAI;IAY5C,OAAO,CAAC,iBAAiB;IAWzB,SAAS,CAAC,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI;IAgBjE,SAAS,CAAC,wBAAwB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAI7D,OAAO,CAAC,mBAAmB;IAuB3B,OAAO,CAAC,4BAA4B;IAiBpC,OAAO,CAAC,oBAAoB,CAE1B;IAGF,OAAO,CAAC,qBAAqB,CAa3B;IAMF,OAAO,CAAC,sBAAsB;IAS9B,OAAO,CAAC,gBAAgB;IA0CxB,OAAO,CAAC,mBAAmB;IAiC3B,SAAS,CAAC,QAAQ,CAAC,aAAa,IAAI,cAAc;cAE/B,wBAAwB,CAAC,MAAM,CAAC,EAAE;QACnD,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;KACjC,GAAG,OAAO;cAWQ,kBAAkB,CAAC,MAAM,CAAC,EAAE;QAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAAA;KAAE,GAAG,OAAO;cAWzE,MAAM,IAAI,cAAc;CAmB5C"}

package/development/popover/popover-base/popover-base.js

@@ -0,0 +1,2 @@
+import { n as SbbPopoverCloseEvent, t as SbbPopoverBaseElement } from "../../popover-base-BcIAVXWF.js";
+export { SbbPopoverBaseElement, SbbPopoverCloseEvent };

package/development/popover/popover-close-button/popover-close-button.component.d.ts

@@ -0,0 +1,21 @@
+import { TemplateResult } from 'lit';
+import { SbbSecondaryButtonElement } from '../../button.pure.ts';
+/**
+ * Popover close button, intended to be placed inside sbb-popover.
+ *
+ * @slot - Use the unnamed slot to add content to the popover-close-button. Not intended to be used in this context.
+ * @slot icon - Slot used to display the icon, if one is set. Not intended to be used in this context.
+ */
+export declare class SbbPopoverCloseButtonElement extends SbbSecondaryButtonElement {
+    static readonly elementName: string;
+    private _languageController;
+    constructor();
+    protected renderTemplate(): TemplateResult;
+    protected renderIconName(): string;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-popover-close-button': SbbPopoverCloseButtonElement;
+    }
+}
+//# sourceMappingURL=popover-close-button.component.d.ts.map

package/development/popover/popover-close-button/popover-close-button.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popover-close-button.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/popover/popover-close-button/popover-close-button.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAE1C,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAGjE;;;;;GAKG;AACH,qBAAa,4BAA6B,SAAQ,yBAAyB;IACzE,gBAAgC,WAAW,EAAE,MAAM,CAA8B;IAEjF,OAAO,CAAC,mBAAmB,CAEzB;;cAOiB,cAAc,IAAI,cAAc;cAIhC,cAAc,IAAI,MAAM;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,0BAA0B,EAAE,4BAA4B,CAAC;KAC1D;CACF"}

package/development/popover/popover-close-button/popover-close-button.component.js

@@ -0,0 +1,30 @@
+import "lit";
+import { SbbLanguageController, i18nClosePopover } from "../../core.js";
+import { SbbSecondaryButtonElement } from "../../button.pure.js";
+//#region src/elements/popover/popover-close-button/popover-close-button.component.ts
+/**
+* Popover close button, intended to be placed inside sbb-popover.
+*
+* @slot - Use the unnamed slot to add content to the popover-close-button. Not intended to be used in this context.
+* @slot icon - Slot used to display the icon, if one is set. Not intended to be used in this context.
+*/
+var SbbPopoverCloseButtonElement = class extends SbbSecondaryButtonElement {
+	static {
+		this.elementName = "sbb-popover-close-button";
+	}
+	constructor() {
+		super();
+		this._languageController = new SbbLanguageController(this).withHandler(() => this.internals.ariaLabel = i18nClosePopover[this._languageController.current]);
+		this.size = "s";
+	}
+	renderTemplate() {
+		return super.renderIconSlot();
+	}
+	renderIconName() {
+		return super.renderIconName() || "cross-small";
+	}
+};
+//#endregion
+export { SbbPopoverCloseButtonElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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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"}