@sbb-esta/lyne-elements 0.0.0 → 0.52.1

package/development/popover/popover.js

@@ -0,0 +1,553 @@
+import { css, html, nothing } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { ref } from "lit/directives/ref.js";
+import { SbbFocusHandler, IS_FOCUSABLE_QUERY, setModalityOnNextFocus, getFirstFocusableElement } from "../core/a11y.js";
+import { SbbOpenCloseBaseElement } from "../core/base-elements.js";
+import { SbbLanguageController } from "../core/controllers.js";
+import { findReferencedElement } from "../core/dom.js";
+import { EventEmitter, composedPathHasAttribute } from "../core/eventing.js";
+import { i18nClosePopover } from "../core/i18n.js";
+import { isEventOnElement, removeAriaOverlayTriggerAttributes, setAriaOverlayTriggerAttributes, getElementPosition } from "../core/overlay.js";
+import "../button/secondary-button.js";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-popover-position: absolute;
+  --sbb-popover-position-x: 0;
+  --sbb-popover-position-y: 0;
+  --sbb-popover-arrow-size: var(--sbb-spacing-fixed-4x);
+  --sbb-popover-arrow-position-x: 0;
+  --sbb-popover-max-width: calc(100% - var(--sbb-spacing-fixed-2x));
+  --sbb-popover-inset: 0 auto auto 0;
+  --sbb-popover-border-radius: var(--sbb-border-radius-8x);
+  --sbb-popover-padding: var(--sbb-spacing-fixed-4x);
+  --sbb-popover-background: var(--sbb-color-white);
+  --sbb-popover-color: var(--sbb-color-charcoal);
+  --sbb-popover-animation-duration: var(
+    --sbb-disable-animation-zero-time,
+    var(--sbb-animation-duration-4x)
+  );
+  --sbb-popover-animation-easing: ease-out;
+  --sbb-popover-transform: translateY(var(--sbb-spacing-fixed-2x));
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-default);
+  display: block;
+}
+
+:host([data-position=above]) {
+  --sbb-popover-transform: translateY(calc(var(--sbb-spacing-fixed-2x) * -1));
+}
+
+:host(:not([data-state=closed])) {
+  --sbb-popover-inset: 0;
+}
+
+.sbb-popover::after,
+.sbb-popover__content::before {
+  content: "";
+  position: absolute;
+  display: block;
+  width: var(--sbb-popover-arrow-size);
+  height: var(--sbb-popover-arrow-size);
+  left: var(--sbb-popover-arrow-position-x);
+  bottom: calc(100% - var(--sbb-popover-arrow-size) / 2);
+  background-color: var(--sbb-popover-background);
+  border-radius: var(--sbb-border-radius-2x) 0;
+  transform: rotate(45deg);
+}
+
+.sbb-popover__container {
+  position: fixed;
+  inset: var(--sbb-popover-inset);
+  pointer-events: none;
+  z-index: var(--sbb-popover-z-index, var(--sbb-overlay-default-z-index));
+  color: var(--sbb-popover-color);
+}
+
+.sbb-popover {
+  box-shadow: var(--sbb-shadow-elevation-level-5-shadow-2-offset-x) var(--sbb-shadow-elevation-level-5-shadow-2-offset-y) var(--sbb-shadow-elevation-level-5-shadow-2-blur) var(--sbb-shadow-elevation-level-5-shadow-2-spread) var(--sbb-shadow-elevation-level-5-hard-2-color), var(--sbb-shadow-elevation-level-5-shadow-1-offset-x) var(--sbb-shadow-elevation-level-5-shadow-1-offset-y) var(--sbb-shadow-elevation-level-5-shadow-1-blur) var(--sbb-shadow-elevation-level-5-shadow-1-spread) var(--sbb-shadow-elevation-level-5-hard-1-color);
+  display: none;
+  position: var(--sbb-popover-position);
+  pointer-events: all;
+  top: var(--sbb-popover-position-y);
+  bottom: unset;
+  left: var(--sbb-popover-position-x);
+  right: unset;
+  border: none;
+  border-radius: var(--sbb-popover-border-radius);
+  padding: 0;
+  max-width: var(--sbb-popover-max-width);
+  width: max-content;
+  background-color: var(--sbb-popover-background);
+  outline: none;
+}
+.sbb-popover:focus-visible:not([data-focus-origin=mouse], [data-focus-origin=touch]) {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) solid var(--sbb-focus-outline-width);
+}
+:host([data-state]:not([data-state=closed])) .sbb-popover {
+  display: block;
+  animation-name: open;
+  animation-duration: var(--sbb-popover-animation-duration);
+  animation-timing-function: var(--sbb-popover-animation-easing);
+}
+:host([data-state][data-state=closing]) .sbb-popover {
+  pointer-events: none;
+  animation-name: close;
+  animation-duration: var(--sbb-popover-animation-duration);
+  animation-timing-function: var(--sbb-popover-animation-easing);
+}
+.sbb-popover::after {
+  box-shadow: var(--sbb-shadow-elevation-level-5-shadow-2-offset-x) var(--sbb-shadow-elevation-level-5-shadow-2-offset-y) var(--sbb-shadow-elevation-level-5-shadow-2-blur) var(--sbb-shadow-elevation-level-5-shadow-2-spread) var(--sbb-shadow-elevation-level-5-hard-2-color), var(--sbb-shadow-elevation-level-5-shadow-1-offset-x) var(--sbb-shadow-elevation-level-5-shadow-1-offset-y) var(--sbb-shadow-elevation-level-5-shadow-1-blur) var(--sbb-shadow-elevation-level-5-shadow-1-spread) var(--sbb-shadow-elevation-level-5-hard-1-color);
+  z-index: -1;
+}
+@media (forced-colors: active) {
+  .sbb-popover::after {
+    outline: var(--sbb-border-width-1x) solid CanvasText;
+  }
+}
+:host([data-position=above]) .sbb-popover::after {
+  top: calc(100% - var(--sbb-popover-arrow-size) / 2);
+}
+@media (forced-colors: active) {
+  .sbb-popover {
+    outline: var(--sbb-border-width-1x) solid CanvasText;
+  }
+}
+.sbb-popover::before {
+  content: "";
+  display: block;
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  background-color: transparent;
+}
+:host([data-position=below]) .sbb-popover::before {
+  inset-block-start: calc(-1 * var(--sbb-spacing-fixed-6x));
+}
+:host([data-position=above]) .sbb-popover::before {
+  inset-block-end: calc(-1 * var(--sbb-spacing-fixed-6x));
+}
+
+.sbb-popover__content {
+  display: flex;
+  gap: var(--sbb-spacing-fixed-4x);
+  border-radius: var(--sbb-popover-border-radius);
+  padding: var(--sbb-popover-padding);
+  outline: none;
+  background-color: var(--sbb-popover-background);
+  overflow: hidden;
+  flex-direction: row-reverse;
+}
+:host([data-position=above]) .sbb-popover__content::before {
+  top: calc(100% - var(--sbb-popover-arrow-size) / 2);
+}
+
+@keyframes open {
+  from {
+    opacity: 0;
+    transform: var(--sbb-popover-transform);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+@keyframes close {
+  from {
+    opacity: 1;
+    transform: translateY(0);
+  }
+  to {
+    opacity: 0;
+    transform: var(--sbb-popover-transform);
+  }
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+const VERTICAL_OFFSET = 16;
+const HORIZONTAL_OFFSET = 32;
+let nextId = 0;
+const popoversRef = /* @__PURE__ */ new Set();
+let SbbPopoverElement = class extends SbbOpenCloseBaseElement {
+  constructor() {
+    super(...arguments);
+    this.hideCloseButton = false;
+    this.hoverTrigger = false;
+    this.openDelay = 0;
+    this.closeDelay = 0;
+    this.willClose = new EventEmitter(
+      this,
+      SbbPopoverElement.events.willClose
+    );
+    this.didClose = new EventEmitter(
+      this,
+      SbbPopoverElement.events.didClose
+    );
+    this._skipCloseFocus = false;
+    this._focusHandler = new SbbFocusHandler();
+    this._hoverTrigger = false;
+    this._language = new SbbLanguageController(this);
+    this._pointerDownListener = (event) => {
+      this._isPointerDownEventOnPopover = isEventOnElement(this._overlay, event);
+    };
+    this._closeOnBackdropClick = (event) => {
+      if (!this._isPointerDownEventOnPopover && !isEventOnElement(this._overlay, event)) {
+        this._nextFocusedElement = event.composedPath().filter((el) => el instanceof window.HTMLElement).find((el) => el.matches(IS_FOCUSABLE_QUERY));
+        clearTimeout(this._closeTimeout);
+        this.close();
+      }
+    };
+    this._onTriggerMouseEnter = () => {
+      if (this.state === "closed" || this.state === "closing") {
+        this._openTimeout = setTimeout(() => 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);
+      }
+    };
+  }
+  /** Opens the popover on trigger click. */
+  open() {
+    var _a;
+    if (this.state !== "closed" && this.state !== "closing" || !this._overlay) {
+      return;
+    }
+    if (!this.willOpen.emit()) {
+      return;
+    }
+    for (const popover of Array.from(popoversRef)) {
+      const state = popover.getAttribute("data-state");
+      if (state && (state === "opened" || state === "opening")) {
+        popover.close();
+      }
+    }
+    this.state = "opening";
+    this.inert = true;
+    this._setPopoverPosition();
+    (_a = this._triggerElement) == null ? void 0 : _a.setAttribute("aria-expanded", "true");
+    this._nextFocusedElement = void 0;
+    this._skipCloseFocus = false;
+  }
+  /** Closes the popover. */
+  close(target) {
+    var _a;
+    if (this.state !== "opened" && this.state !== "opening") {
+      return;
+    }
+    this._popoverCloseElement = target;
+    if (!this.willClose.emit({ closeTarget: target })) {
+      return;
+    }
+    this.state = "closing";
+    this.inert = true;
+    (_a = this._triggerElement) == null ? void 0 : _a.setAttribute("aria-expanded", "false");
+  }
+  // Closes the popover on "Esc" key pressed and traps focus within the popover.
+  _onKeydownEvent(event) {
+    if (this.state !== "opened") {
+      return;
+    }
+    if (event.key === "Escape") {
+      this.close();
+      return;
+    }
+  }
+  // Removes trigger click listener on trigger change.
+  _removeTriggerClickListener(newValue, oldValue) {
+    var _a, _b;
+    if (newValue !== oldValue) {
+      (_a = this._popoverController) == null ? void 0 : _a.abort();
+      (_b = this._openStateController) == null ? void 0 : _b.abort();
+      this._configure();
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (!this.id) {
+      this.id = this.id || `sbb-popover-${++nextId}`;
+    }
+    this._configure();
+    this.state = "closed";
+    popoversRef.add(this);
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("trigger")) {
+      this._removeTriggerClickListener(this.trigger, changedProperties.get("trigger"));
+    }
+    if (changedProperties.has("hoverTrigger")) {
+      this._configure();
+    }
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    if (this._hoverTrigger) {
+      this._overlay.addEventListener("mouseenter", () => this._onOverlayMouseEnter());
+      this._overlay.addEventListener("mouseleave", () => this._onOverlayMouseLeave());
+    }
+  }
+  disconnectedCallback() {
+    var _a, _b;
+    super.disconnectedCallback();
+    (_a = this._popoverController) == null ? void 0 : _a.abort();
+    (_b = this._openStateController) == null ? void 0 : _b.abort();
+    this._focusHandler.disconnect();
+    popoversRef.delete(this);
+  }
+  // Check if the trigger is valid and attach click event listeners.
+  _configure() {
+    var _a;
+    removeAriaOverlayTriggerAttributes(this._triggerElement);
+    if (!this.trigger) {
+      return;
+    }
+    this._triggerElement = findReferencedElement(this.trigger);
+    if (!this._triggerElement) {
+      return;
+    }
+    setAriaOverlayTriggerAttributes(this._triggerElement, "dialog", this.id, this.state);
+    this._hoverTrigger = this.hoverTrigger && !window.matchMedia("(pointer: coarse)").matches;
+    (_a = this._popoverController) == null ? void 0 : _a.abort();
+    this._popoverController = new AbortController();
+    if (this._hoverTrigger) {
+      this._triggerElement.addEventListener("mouseenter", this._onTriggerMouseEnter, {
+        signal: this._popoverController.signal
+      });
+      this._triggerElement.addEventListener("mouseleave", this._onTriggerMouseLeave, {
+        signal: this._popoverController.signal
+      });
+      this._triggerElement.addEventListener(
+        "keydown",
+        (evt) => {
+          if (evt.code === "Space" || evt.code === "Enter") {
+            this.open();
+          }
+        },
+        {
+          signal: this._popoverController.signal
+        }
+      );
+    } else {
+      this._triggerElement.addEventListener(
+        "click",
+        () => {
+          this.state === "closed" && this.open();
+        },
+        {
+          signal: this._popoverController.signal
+        }
+      );
+    }
+  }
+  _attachWindowEvents() {
+    this._openStateController = new AbortController();
+    document.addEventListener("scroll", () => this._setPopoverPosition(), {
+      passive: true,
+      signal: this._openStateController.signal
+    });
+    window.addEventListener("resize", () => this._setPopoverPosition(), {
+      passive: true,
+      signal: this._openStateController.signal
+    });
+    window.addEventListener("keydown", (event) => this._onKeydownEvent(event), {
+      signal: this._openStateController.signal
+    });
+    window.addEventListener("pointerdown", this._pointerDownListener, {
+      signal: this._openStateController.signal
+    });
+    window.addEventListener("pointerup", this._closeOnBackdropClick, {
+      signal: this._openStateController.signal
+    });
+  }
+  // Close the popover on click of any element that has the 'sbb-popover-close' attribute.
+  _closeOnSbbPopoverCloseClick(event) {
+    const closeElement = composedPathHasAttribute(event, "sbb-popover-close", this);
+    if (closeElement && !closeElement.hasAttribute("disabled")) {
+      clearTimeout(this._closeTimeout);
+      this.close(closeElement);
+    }
+  }
+  // Set popover position (x, y) to '0' once the popover is closed and the transition ended to prevent the
+  // viewport from overflowing. And set the focus to the first focusable element once the popover is open.
+  // In rare cases it can be that the animationEnd event is triggered twice.
+  // To avoid entering a corrupt state, exit when state is not expected.
+  _onPopoverAnimationEnd(event) {
+    var _a, _b, _c, _d;
+    if (event.animationName === "open" && this.state === "opening") {
+      this.state = "opened";
+      this.didOpen.emit();
+      this.inert = false;
+      this._attachWindowEvents();
+      this._setPopoverFocus();
+      this._focusHandler.trap(this, {
+        postFilter: (el) => el !== this._overlay
+      });
+    } else if (event.animationName === "close" && this.state === "closing") {
+      this.state = "closed";
+      (_b = (_a = this._overlay) == null ? void 0 : _a.firstElementChild) == null ? void 0 : _b.scrollTo(0, 0);
+      (_c = this._overlay) == null ? void 0 : _c.removeAttribute("tabindex");
+      if (!this._skipCloseFocus) {
+        const elementToFocus = this._nextFocusedElement || this._triggerElement;
+        setModalityOnNextFocus(elementToFocus);
+        elementToFocus == null ? void 0 : elementToFocus.focus();
+      }
+      this.didClose.emit({ closeTarget: this._popoverCloseElement });
+      (_d = this._openStateController) == null ? void 0 : _d.abort();
+      this._focusHandler.disconnect();
+    }
+  }
+  // Set focus on the first focusable element.
+  _setPopoverFocus() {
+    const firstFocusable = this.shadowRoot.querySelector("[sbb-popover-close]") || getFirstFocusableElement(
+      Array.from(this.children).filter((e) => e instanceof window.HTMLElement)
+    );
+    if (firstFocusable) {
+      setModalityOnNextFocus(firstFocusable);
+      firstFocusable.focus();
+    } else {
+      this._overlay.setAttribute("tabindex", "0");
+      setModalityOnNextFocus(this._overlay);
+      this._overlay.focus();
+      this._overlay.addEventListener(
+        "blur",
+        () => {
+          setTimeout(() => {
+            var _a;
+            if (document.visibilityState !== "hidden") {
+              (_a = this._overlay) == null ? void 0 : _a.removeAttribute("tabindex");
+              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
+      }
+    );
+    this.setAttribute("data-position", popoverPosition.alignment.vertical);
+    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`);
+  }
+  render() {
+    const closeButton = html`
+      <span class="sbb-popover__close">
+        <sbb-secondary-button
+          aria-label=${this.accessibilityCloseLabel || i18nClosePopover[this._language.current]}
+          size="s"
+          type="button"
+          icon-name="cross-small"
+          sbb-popover-close
+        ></sbb-secondary-button>
+      </span>
+    `;
+    return html`
+      <div class="sbb-popover__container">
+        <div
+          @animationend=${(event) => this._onPopoverAnimationEnd(event)}
+          class="sbb-popover"
+          role="tooltip"
+          ${ref((el) => this._overlay = el)}
+        >
+          <div
+            @click=${(event) => this._closeOnSbbPopoverCloseClick(event)}
+            class="sbb-popover__content"
+          >
+            ${!this.hideCloseButton && !this._hoverTrigger ? closeButton : nothing}
+            <span>
+              <slot>No content</slot>
+            </span>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+};
+SbbPopoverElement.styles = style;
+__decorateClass([
+  property()
+], SbbPopoverElement.prototype, "trigger", 2);
+__decorateClass([
+  property({ attribute: "hide-close-button", type: Boolean })
+], SbbPopoverElement.prototype, "hideCloseButton", 2);
+__decorateClass([
+  property({ attribute: "hover-trigger", type: Boolean })
+], SbbPopoverElement.prototype, "hoverTrigger", 2);
+__decorateClass([
+  property({ attribute: "open-delay", type: Number })
+], SbbPopoverElement.prototype, "openDelay", 2);
+__decorateClass([
+  property({ attribute: "close-delay", type: Number })
+], SbbPopoverElement.prototype, "closeDelay", 2);
+__decorateClass([
+  property({ attribute: "accessibility-close-label" })
+], SbbPopoverElement.prototype, "accessibilityCloseLabel", 2);
+SbbPopoverElement = __decorateClass([
+  customElement("sbb-popover")
+], SbbPopoverElement);
+export {
+  SbbPopoverElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"popover.js","sources":["../../../../src/elements/popover/popover/popover.ts"],"sourcesContent":["import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, nothing } from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport {\n  getFirstFocusableElement,\n  IS_FOCUSABLE_QUERY,\n  SbbFocusHandler,\n  setModalityOnNextFocus,\n} from '../../core/a11y.js';\nimport { SbbOpenCloseBaseElement } from '../../core/base-elements.js';\nimport { SbbLanguageController } from '../../core/controllers.js';\nimport { findReferencedElement } from '../../core/dom.js';\nimport { composedPathHasAttribute, EventEmitter } from '../../core/eventing.js';\nimport { i18nClosePopover } from '../../core/i18n.js';\nimport type { SbbOpenedClosedState } from '../../core/interfaces.js';\nimport {\n  getElementPosition,\n  isEventOnElement,\n  removeAriaOverlayTriggerAttributes,\n  setAriaOverlayTriggerAttributes,\n} from '../../core/overlay.js';\n\nimport style from './popover.scss?lit&inline';\n\nimport '../../button/secondary-button.js';\n\nconst VERTICAL_OFFSET = 16;\nconst HORIZONTAL_OFFSET = 32;\n\nlet nextId = 0;\n\nconst popoversRef = new Set<SbbPopoverElement>();\n\n/**\n * It displays contextual information within a popover.\n *\n * @slot - Use the unnamed slot to add content into the popover.\n * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-popover` starts the opening transition. Can be canceled.\n * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-popover` is opened.\n * @event {CustomEvent<{ closeTarget: HTMLElement }>} willClose - Emits whenever the `sbb-popover` begins the closing\n * transition. Can be canceled.\n * @event {CustomEvent<{ closeTarget: HTMLElement }>} didClose - Emits whenever the `sbb-popover` is closed.\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 */\n@customElement('sbb-popover')\nexport class SbbPopoverElement extends SbbOpenCloseBaseElement {\n  public static override styles: CSSResultGroup = style;\n\n  /**\n   * The element that will trigger the popover overlay.\n   * Accepts both a string (id of an element) or an HTML element.\n   */\n  @property() public trigger?: string | HTMLElement;\n\n  /** Whether the close button should be hidden. */\n  @property({ attribute: 'hide-close-button', type: Boolean }) public hideCloseButton?: boolean =\n    false;\n\n  /** Whether the popover should be triggered on hover. */\n  @property({ attribute: 'hover-trigger', type: Boolean }) public hoverTrigger: boolean = false;\n\n  /** Open the popover after a certain delay. */\n  @property({ attribute: 'open-delay', type: Number }) public openDelay? = 0;\n\n  /** Close the popover after a certain delay. */\n  @property({ attribute: 'close-delay', type: Number }) public closeDelay? = 0;\n\n  /** This will be forwarded as aria-label to the close button element. */\n  @property({ attribute: 'accessibility-close-label' }) public accessibilityCloseLabel:\n    | string\n    | undefined;\n\n  /** Emits whenever the `sbb-popover` begins the closing transition. */\n  protected override willClose: EventEmitter<{ closeTarget?: HTMLElement }> = new EventEmitter(\n    this,\n    SbbPopoverElement.events.willClose,\n  );\n\n  /** Emits whenever the `sbb-popover` is closed. */\n  protected override didClose: EventEmitter<{ closeTarget?: HTMLElement }> = new EventEmitter(\n    this,\n    SbbPopoverElement.events.didClose,\n  );\n\n  private _overlay!: HTMLDivElement;\n  private _triggerElement?: HTMLElement | null;\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 _popoverController!: AbortController;\n  private _openStateController!: AbortController;\n  private _focusHandler = new SbbFocusHandler();\n  private _hoverTrigger = false;\n  private _openTimeout?: ReturnType<typeof setTimeout>;\n  private _closeTimeout?: ReturnType<typeof setTimeout>;\n  private _language = new SbbLanguageController(this);\n\n  /** Opens the popover on trigger click. */\n  public open(): void {\n    if ((this.state !== 'closed' && this.state !== 'closing') || !this._overlay) {\n      return;\n    }\n\n    if (!this.willOpen.emit()) {\n      return;\n    }\n\n    // Close the other popovers\n    for (const popover of Array.from(popoversRef)) {\n      const state = popover.getAttribute('data-state') as SbbOpenedClosedState;\n      if (state && (state === 'opened' || state === 'opening')) {\n        popover.close();\n      }\n    }\n\n    this.state = 'opening';\n    this.inert = true;\n    this._setPopoverPosition();\n    this._triggerElement?.setAttribute('aria-expanded', 'true');\n    this._nextFocusedElement = undefined;\n    this._skipCloseFocus = false;\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.willClose.emit({ closeTarget: target })) {\n      return;\n    }\n\n    this.state = 'closing';\n    this.inert = true;\n    this._triggerElement?.setAttribute('aria-expanded', 'false');\n  }\n\n  // Closes the popover on \"Esc\" key pressed and traps focus within the popover.\n  private _onKeydownEvent(event: KeyboardEvent): void {\n    if (this.state !== 'opened') {\n      return;\n    }\n\n    if (event.key === 'Escape') {\n      this.close();\n      return;\n    }\n  }\n\n  // Removes trigger click listener on trigger change.\n  private _removeTriggerClickListener(\n    newValue?: string | HTMLElement,\n    oldValue?: string | HTMLElement,\n  ): void {\n    if (newValue !== oldValue) {\n      this._popoverController?.abort();\n      this._openStateController?.abort();\n      this._configure();\n    }\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    if (!this.id) {\n      this.id = this.id || `sbb-popover-${++nextId}`;\n    }\n\n    // Validate trigger element and attach event listeners\n    this._configure();\n    this.state = 'closed';\n    popoversRef.add(this as SbbPopoverElement);\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('trigger')) {\n      this._removeTriggerClickListener(this.trigger, changedProperties.get('trigger'));\n    }\n\n    if (changedProperties.has('hoverTrigger')) {\n      this._configure();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    if (this._hoverTrigger) {\n      this._overlay.addEventListener('mouseenter', () => this._onOverlayMouseEnter());\n      this._overlay.addEventListener('mouseleave', () => this._onOverlayMouseLeave());\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._popoverController?.abort();\n    this._openStateController?.abort();\n    this._focusHandler.disconnect();\n    popoversRef.delete(this as SbbPopoverElement);\n  }\n\n  // Check if the trigger is valid and attach click event listeners.\n  private _configure(): void {\n    removeAriaOverlayTriggerAttributes(this._triggerElement);\n\n    if (!this.trigger) {\n      return;\n    }\n\n    this._triggerElement = findReferencedElement(this.trigger);\n\n    if (!this._triggerElement) {\n      return;\n    }\n\n    setAriaOverlayTriggerAttributes(this._triggerElement, 'dialog', this.id, this.state);\n\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    this._hoverTrigger = this.hoverTrigger && !window.matchMedia('(pointer: coarse)').matches;\n\n    this._popoverController?.abort();\n    this._popoverController = new AbortController();\n    if (this._hoverTrigger) {\n      this._triggerElement.addEventListener('mouseenter', this._onTriggerMouseEnter, {\n        signal: this._popoverController.signal,\n      });\n\n      this._triggerElement.addEventListener('mouseleave', this._onTriggerMouseLeave, {\n        signal: this._popoverController.signal,\n      });\n\n      this._triggerElement.addEventListener(\n        'keydown',\n        (evt: KeyboardEvent) => {\n          if (evt.code === 'Space' || evt.code === 'Enter') {\n            this.open();\n          }\n        },\n        {\n          signal: this._popoverController.signal,\n        },\n      );\n    } else {\n      this._triggerElement.addEventListener(\n        'click',\n        () => {\n          this.state === 'closed' && this.open();\n        },\n        {\n          signal: this._popoverController.signal,\n        },\n      );\n    }\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    });\n    window.addEventListener('resize', () => this._setPopoverPosition(), {\n      passive: true,\n      signal: this._openStateController.signal,\n    });\n    window.addEventListener('keydown', (event: KeyboardEvent) => this._onKeydownEvent(event), {\n      signal: this._openStateController.signal,\n    });\n\n    // Close popover on backdrop click\n    window.addEventListener('pointerdown', this._pointerDownListener, {\n      signal: this._openStateController.signal,\n    });\n    window.addEventListener('pointerup', this._closeOnBackdropClick, {\n      signal: this._openStateController.signal,\n    });\n  }\n\n  // Close the popover on click of any element that has the 'sbb-popover-close' attribute.\n  private _closeOnSbbPopoverCloseClick(event: Event): void {\n    const closeElement = composedPathHasAttribute(event, 'sbb-popover-close', this);\n\n    if (closeElement && !closeElement.hasAttribute('disabled')) {\n      clearTimeout(this._closeTimeout);\n      this.close(closeElement);\n    }\n  }\n\n  // Check if the pointerdown event target is triggered on the popover.\n  private _pointerDownListener = (event: PointerEvent): void => {\n    this._isPointerDownEventOnPopover = isEventOnElement(this._overlay, event);\n  };\n\n  // Close popover on backdrop click.\n  private _closeOnBackdropClick = (event: PointerEvent): void => {\n    if (!this._isPointerDownEventOnPopover && !isEventOnElement(this._overlay, event)) {\n      this._nextFocusedElement = event\n        .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  private _onTriggerMouseEnter = (): void => {\n    if (this.state === 'closed' || this.state === 'closing') {\n      this._openTimeout = setTimeout(() => this.open(), 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  // 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.state = 'opened';\n      this.didOpen.emit();\n      this.inert = false;\n      this._attachWindowEvents();\n      this._setPopoverFocus();\n      this._focusHandler.trap(this, {\n        postFilter: (el) => el !== this._overlay,\n      });\n    } else if (event.animationName === 'close' && this.state === 'closing') {\n      this.state = 'closed';\n      this._overlay?.firstElementChild?.scrollTo(0, 0);\n      this._overlay?.removeAttribute('tabindex');\n\n      if (!this._skipCloseFocus) {\n        const elementToFocus = this._nextFocusedElement || this._triggerElement;\n\n        setModalityOnNextFocus(elementToFocus);\n        // To enable focusing other element than the trigger, we need to call focus() a second time.\n        elementToFocus?.focus();\n      }\n\n      this.didClose.emit({ closeTarget: this._popoverCloseElement });\n      this._openStateController?.abort();\n      this._focusHandler.disconnect();\n    }\n  }\n\n  // Set focus on the first focusable element.\n  private _setPopoverFocus(): void {\n    const firstFocusable =\n      this.shadowRoot!.querySelector<HTMLElement>('[sbb-popover-close]') ||\n      getFirstFocusableElement(\n        Array.from(this.children).filter((e): e is HTMLElement => e instanceof window.HTMLElement),\n      );\n    if (firstFocusable) {\n      setModalityOnNextFocus(firstFocusable);\n      firstFocusable.focus();\n    } else {\n      this._overlay.setAttribute('tabindex', '0');\n      setModalityOnNextFocus(this._overlay);\n      this._overlay.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._overlay.addEventListener(\n        'blur',\n        (): void => {\n          setTimeout(() => {\n            if (document.visibilityState !== 'hidden') {\n              this._overlay?.removeAttribute('tabindex');\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    this.setAttribute('data-position', popoverPosition.alignment.vertical);\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  }\n\n  protected override render(): TemplateResult {\n    const closeButton = html`\n      <span class=\"sbb-popover__close\">\n        <sbb-secondary-button\n          aria-label=${this.accessibilityCloseLabel || i18nClosePopover[this._language.current]}\n          size=\"s\"\n          type=\"button\"\n          icon-name=\"cross-small\"\n          sbb-popover-close\n        ></sbb-secondary-button>\n      </span>\n    `;\n\n    return html`\n      <div class=\"sbb-popover__container\">\n        <div\n          @animationend=${(event: AnimationEvent) => this._onPopoverAnimationEnd(event)}\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.hideCloseButton && !this._hoverTrigger ? closeButton : nothing}\n            <span>\n              <slot>No content</slot>\n            </span>\n          </div>\n        </div>\n      </div>\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"],"names":[],"mappings":"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"}

package/development/popover.d.ts

@@ -0,0 +1,3 @@
+export * from './popover/popover.js';
+export * from './popover/popover-trigger.js';
+//# sourceMappingURL=popover.d.ts.map

package/development/popover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popover.d.ts","sourceRoot":"","sources":["../../../src/elements/popover.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC"}

package/development/popover.js

@@ -0,0 +1,3 @@
+export * from "./popover/popover.js";
+export * from "./popover/popover-trigger.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OyJ9