@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/overlay.js

@@ -0,0 +1,484 @@
+import { css, nothing } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { html, unsafeStatic } from "lit/static-html.js";
+import { SbbFocusHandler, setModalityOnNextFocus, getFirstFocusableElement } from "./core/a11y.js";
+import { EventEmitter } from "./core/eventing.js";
+import { i18nDialog, i18nCloseDialog, i18nGoBack } from "./core/i18n.js";
+import { applyInertMechanism, removeInertMechanism } from "./core/overlay.js";
+import { SbbOpenCloseBaseElement } from "./core/base-elements.js";
+import { SbbLanguageController } from "./core/controllers.js";
+import { SbbScrollHandler, hostContext } from "./core/dom.js";
+import { SbbNegativeMixin } from "./core/mixins.js";
+import "./button/secondary-button.js";
+import "./button/transparent-button.js";
+import "./container.js";
+import "./screen-reader-only.js";
+var __defProp$1 = Object.defineProperty;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = void 0;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(target, key, result) || result;
+  if (result)
+    __defProp$1(target, key, result);
+  return result;
+};
+const overlayRefs = [];
+const _SbbOverlayBaseElement = class _SbbOverlayBaseElement2 extends SbbNegativeMixin(SbbOpenCloseBaseElement) {
+  constructor() {
+    super(...arguments);
+    this.didClose = new EventEmitter(
+      this,
+      _SbbOverlayBaseElement2.events.didClose
+    );
+    this.focusHandler = new SbbFocusHandler();
+    this.scrollHandler = new SbbScrollHandler();
+    this.ariaLiveRefToggle = false;
+    this.language = new SbbLanguageController(this);
+  }
+  /** Closes the component. */
+  close(result, target) {
+    if (this.state !== "opened") {
+      return;
+    }
+    this.returnValue = result;
+    this.overlayCloseElement = target;
+    const eventData = {
+      returnValue: this.returnValue,
+      closeTarget: this.overlayCloseElement
+    };
+    if (!this.willClose.emit(eventData)) {
+      return;
+    }
+    this.state = "closing";
+    this.removeAriaLiveRefContent();
+  }
+  connectedCallback() {
+    var _a;
+    super.connectedCallback();
+    (_a = this.overlayController) == null ? void 0 : _a.abort();
+    this.overlayController = new AbortController();
+    if (this.state === "opened") {
+      applyInertMechanism(this);
+    }
+  }
+  firstUpdated(changedProperties) {
+    this.ariaLiveRef = this.shadowRoot.querySelector("sbb-screen-reader-only");
+    super.firstUpdated(changedProperties);
+  }
+  disconnectedCallback() {
+    var _a, _b;
+    super.disconnectedCallback();
+    (_a = this.overlayController) == null ? void 0 : _a.abort();
+    (_b = this.openOverlayController) == null ? void 0 : _b.abort();
+    this.focusHandler.disconnect();
+    this.removeInstanceFromGlobalCollection();
+    removeInertMechanism();
+  }
+  attachOpenOverlayEvents() {
+    this.openOverlayController = new AbortController();
+    window.addEventListener(
+      "keydown",
+      (event) => {
+        this.removeAriaLiveRefContent();
+        this.onKeydownEvent(event);
+      },
+      {
+        signal: this.openOverlayController.signal
+      }
+    );
+    window.addEventListener("click", () => this.removeAriaLiveRefContent(), {
+      signal: this.openOverlayController.signal
+    });
+  }
+  onKeydownEvent(event) {
+    if (this.state !== "opened") {
+      return;
+    }
+    if (event.key === "Escape") {
+      overlayRefs[overlayRefs.length - 1].close();
+      return;
+    }
+  }
+  removeInstanceFromGlobalCollection() {
+    overlayRefs.splice(overlayRefs.indexOf(this), 1);
+  }
+  // Close the component on click of any element that has the `closeAttribute` attribute.
+  closeOnSbbOverlayCloseClick(event) {
+    const overlayCloseElement = event.composedPath().filter((e) => e instanceof window.HTMLElement).find(
+      (target) => target.hasAttribute(this.closeAttribute) && !target.hasAttribute("disabled")
+    );
+    if (!overlayCloseElement) {
+      return;
+    }
+    const closestForm = overlayCloseElement.getAttribute("type") === "submit" ? hostContext("form", overlayCloseElement) : void 0;
+    overlayRefs[overlayRefs.length - 1].close(closestForm, overlayCloseElement);
+  }
+  removeAriaLiveRefContent() {
+    this.ariaLiveRef.textContent = "";
+  }
+  setAriaLiveRefContent(label) {
+    this.ariaLiveRefToggle = !this.ariaLiveRefToggle;
+    this.ariaLiveRef.textContent = `${i18nDialog[this.language.current]}${label ? `, ${label}` : ""}${this.ariaLiveRefToggle ? " " : ""}`;
+  }
+};
+__decorateClass$1([
+  property({ attribute: "accessibility-label" })
+], _SbbOverlayBaseElement.prototype, "accessibilityLabel");
+let SbbOverlayBaseElement = _SbbOverlayBaseElement;
+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-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: var(--sbb-color-black-alpha-30);
+  --sbb-scrollbar-color-hover: var(--sbb-color-black-alpha-60);
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-overlay-background-color: var(--sbb-color-milk);
+  --sbb-overlay-height: 100%;
+  --sbb-overlay-inset: 0 auto auto 0;
+  --sbb-overlay-padding-block: calc(
+    var(--sbb-spacing-responsive-xxl) + var(--sbb-spacing-responsive-l)
+  );
+  --sbb-overlay-animation-duration: var(
+    --sbb-disable-animation-zero-time,
+    var(--sbb-animation-duration-6x)
+  );
+  --sbb-overlay-animation-easing: ease;
+  --sbb-overlay-pointer-events: none;
+  --sbb-overlay-content-transition: transform var(--sbb-overlay-animation-duration)
+    var(--sbb-overlay-animation-easing);
+  display: block;
+  position: fixed;
+  inset: var(--sbb-overlay-inset);
+  z-index: var(--sbb-overlay-z-index, var(--sbb-overlay-default-z-index));
+}
+@media (min-width: calc(64rem)) {
+  :host {
+    --sbb-overlay-padding-block: var(--sbb-spacing-responsive-xl);
+  }
+}
+
+:host(:is([data-state=opened], [data-state=opening])) {
+  --sbb-overlay-pointer-events: all;
+}
+
+:host([negative]) {
+  --sbb-scrollbar-color: var(--sbb-color-white-alpha-30);
+  --sbb-scrollbar-color-hover: var(--sbb-color-white-alpha-60);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+  --sbb-overlay-color: var(--sbb-color-white);
+  --sbb-overlay-background-color: var(--sbb-color-midnight);
+}
+
+:host(:not([data-state=closed])) {
+  --sbb-overlay-inset: 0;
+}
+
+.sbb-overlay__container {
+  background-color: var(--sbb-overlay-background-color);
+  pointer-events: var(--sbb-overlay-pointer-events);
+  display: flex;
+  align-items: center;
+  position: fixed;
+  inset: var(--sbb-overlay-inset);
+}
+
+.sbb-overlay {
+  display: none;
+  position: absolute;
+  inset-inline: 0;
+  margin: auto;
+  padding: 0;
+  border: none;
+  height: var(--sbb-overlay-height);
+  overflow: auto;
+  color: var(--sbb-overlay-color);
+}
+:host([data-state]:not([data-state=closed])) .sbb-overlay {
+  display: block;
+  animation-name: open;
+  animation-duration: var(--sbb-overlay-animation-duration);
+  animation-timing-function: ease;
+}
+:host([data-state][data-state=closing]) .sbb-overlay {
+  pointer-events: none;
+  animation-name: close;
+}
+
+.sbb-overlay__wrapper {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  height: var(--sbb-overlay-height);
+  outline: none;
+  position: fixed;
+}
+@media (min-width: calc(52.5rem)) {
+  .sbb-overlay__wrapper {
+    position: sticky;
+    inset-block-start: 0;
+    height: auto;
+  }
+}
+
+.sbb-overlay__header {
+  position: absolute;
+  inset-inline-start: 0;
+  display: flex;
+  pointer-events: none;
+  align-items: start;
+  justify-content: space-between;
+  width: 100%;
+  padding: var(--sbb-spacing-responsive-xs);
+  padding-block-end: 0;
+  z-index: 1;
+}
+.sbb-overlay__header * {
+  pointer-events: all;
+}
+
+.sbb-overlay__close {
+  margin-inline-start: auto;
+}
+
+.sbb-overlay__content {
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+  /* Scrollbar itself */
+  /* Hide button (top and bottom of the scrollbar) */
+  height: 100vh;
+  overflow: auto;
+  -webkit-overflow-scrolling: touch;
+}
+.sbb-overlay__content::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-overlay__content::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-overlay__content::-webkit-scrollbar-thumb {
+  background-color: var(--sbb-scrollbar-color, currentcolor);
+  border: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width))) solid transparent;
+  border-radius: var(--sbb-border-radius-4x);
+  background-clip: padding-box;
+}
+.sbb-overlay__content::-webkit-scrollbar-thumb:hover {
+  background-color: var(--sbb-scrollbar-color-hover, currentcolor);
+  border-width: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width-hover)));
+}
+.sbb-overlay__content::-webkit-scrollbar-button, .sbb-overlay__content::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-overlay__content {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+
+.sbb-overlay__content-container {
+  padding-block: var(--sbb-overlay-padding-block);
+}
+
+@keyframes open {
+  from {
+    opacity: 0;
+    transform: translateY(var(--sbb-spacing-fixed-4x));
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0%);
+  }
+}
+@keyframes close {
+  from {
+    opacity: 1;
+    transform: translateY(0%);
+  }
+  to {
+    opacity: 0;
+    transform: translateY(var(--sbb-spacing-fixed-4x));
+  }
+}`;
+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;
+};
+let SbbOverlayElement = class extends SbbOverlayBaseElement {
+  constructor() {
+    super(...arguments);
+    this.expanded = false;
+    this.backButton = false;
+    this.closeAttribute = "sbb-overlay-close";
+    this._backClick = new EventEmitter(
+      this,
+      SbbOverlayElement.events.backClick
+    );
+    this._overlayContentElement = null;
+  }
+  /** Opens the component. */
+  open() {
+    var _a;
+    if (this.state !== "closed") {
+      return;
+    }
+    this.lastFocusedElement = document.activeElement;
+    this._overlayContentElement = (_a = this.shadowRoot) == null ? void 0 : _a.querySelector(
+      ".sbb-overlay__content"
+    );
+    if (!this.willOpen.emit()) {
+      return;
+    }
+    this.state = "opening";
+    overlayRefs.push(this);
+    this.scrollHandler.disableScroll();
+  }
+  // Wait for overlay transition to complete.
+  // 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.
+  onOverlayAnimationEnd(event) {
+    var _a, _b, _c;
+    if (event.animationName === "open" && this.state === "opening") {
+      this.state = "opened";
+      this.didOpen.emit();
+      applyInertMechanism(this);
+      this.attachOpenOverlayEvents();
+      this.setOverlayFocus();
+      setTimeout(() => this.setAriaLiveRefContent(this.accessibilityLabel));
+      this.focusHandler.trap(this);
+    } else if (event.animationName === "close" && this.state === "closing") {
+      (_a = this._overlayContentElement) == null ? void 0 : _a.scrollTo(0, 0);
+      this.state = "closed";
+      removeInertMechanism();
+      setModalityOnNextFocus(this.lastFocusedElement);
+      (_b = this.lastFocusedElement) == null ? void 0 : _b.focus();
+      (_c = this.openOverlayController) == null ? void 0 : _c.abort();
+      this.focusHandler.disconnect();
+      this.removeInstanceFromGlobalCollection();
+      !overlayRefs.length && this.scrollHandler.enableScroll();
+      this.didClose.emit({
+        returnValue: this.returnValue,
+        closeTarget: this.overlayCloseElement
+      });
+    }
+  }
+  // Set focus on the first focusable element.
+  setOverlayFocus() {
+    const firstFocusable = getFirstFocusableElement(
+      Array.from(this.shadowRoot.children).filter(
+        (e) => e instanceof window.HTMLElement
+      )
+    );
+    setModalityOnNextFocus(firstFocusable);
+    firstFocusable == null ? void 0 : firstFocusable.focus();
+  }
+  render() {
+    const TAG_NAME = this.negative ? "sbb-transparent-button" : "sbb-secondary-button";
+    const closeButton = html`
+      <${unsafeStatic(TAG_NAME)}
+        class="sbb-overlay__close"
+        aria-label=${this.accessibilityCloseLabel || i18nCloseDialog[this.language.current]}
+        ?negative=${this.negative}
+        size="m"
+        type="button"
+        icon-name="cross-small"
+        sbb-overlay-close
+      ></${unsafeStatic(TAG_NAME)}>
+    `;
+    const backButton = html`
+      <${unsafeStatic(TAG_NAME)}
+        class="sbb-overlay__back"
+        aria-label=${this.accessibilityBackLabel || i18nGoBack[this.language.current]}
+        ?negative=${this.negative}
+        size="m"
+        type="button"
+        icon-name="chevron-small-left-small"
+        @click=${() => this._backClick.emit()}
+      ></${unsafeStatic(TAG_NAME)}>
+    `;
+    return html`
+      <div class="sbb-overlay__container">
+        <div
+          @animationend=${(event) => this.onOverlayAnimationEnd(event)}
+          class="sbb-overlay"
+        >
+          <div
+            @click=${(event) => this.closeOnSbbOverlayCloseClick(event)}
+            class="sbb-overlay__wrapper"
+          >
+            <div class="sbb-overlay__header">
+              ${this.backButton ? backButton : nothing} ${closeButton}
+            </div>
+            <div class="sbb-overlay__content">
+              <sbb-container
+                class="sbb-overlay__content-container"
+                ?expanded=${this.expanded}
+                color="transparent"
+              >
+                <slot></slot>
+              </sbb-container>
+            </div>
+          </div>
+        </div>
+      </div>
+      <sbb-screen-reader-only aria-live="polite"></sbb-screen-reader-only>
+    `;
+  }
+};
+SbbOverlayElement.styles = style;
+SbbOverlayElement.events = {
+  willOpen: "willOpen",
+  didOpen: "didOpen",
+  willClose: "willClose",
+  didClose: "didClose",
+  backClick: "requestBackAction"
+};
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbOverlayElement.prototype, "expanded", 2);
+__decorateClass([
+  property({ attribute: "back-button", type: Boolean })
+], SbbOverlayElement.prototype, "backButton", 2);
+__decorateClass([
+  property({ attribute: "accessibility-close-label" })
+], SbbOverlayElement.prototype, "accessibilityCloseLabel", 2);
+__decorateClass([
+  property({ attribute: "accessibility-back-label" })
+], SbbOverlayElement.prototype, "accessibilityBackLabel", 2);
+SbbOverlayElement = __decorateClass([
+  customElement("sbb-overlay")
+], SbbOverlayElement);
+export {
+  SbbOverlayBaseElement,
+  SbbOverlayElement,
+  overlayRefs
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay.js","sources":["../../../src/elements/overlay/overlay-base-element.ts","../../../src/elements/overlay/overlay.ts"],"sourcesContent":["import { type PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbFocusHandler } from '../core/a11y.js';\nimport { SbbOpenCloseBaseElement } from '../core/base-elements.js';\nimport { SbbLanguageController } from '../core/controllers.js';\nimport { hostContext, SbbScrollHandler } from '../core/dom.js';\nimport { EventEmitter } from '../core/eventing.js';\nimport { i18nDialog } from '../core/i18n.js';\nimport type { SbbOverlayCloseEventDetails } from '../core/interfaces.js';\nimport { SbbNegativeMixin } from '../core/mixins.js';\nimport { applyInertMechanism, removeInertMechanism } from '../core/overlay.js';\nimport type { SbbScreenReaderOnlyElement } from '../screen-reader-only.js';\n\n// A global collection of existing overlays.\nexport const overlayRefs: SbbOverlayBaseElement[] = [];\n\nexport abstract class SbbOverlayBaseElement extends SbbNegativeMixin(SbbOpenCloseBaseElement) {\n  /** This will be forwarded as aria-label to the relevant nested element to describe the purpose of the overlay. */\n  @property({ attribute: 'accessibility-label' }) public accessibilityLabel: string | undefined;\n\n  /** Emits whenever the component is closed. */\n  protected override didClose: EventEmitter<SbbOverlayCloseEventDetails> = new EventEmitter(\n    this,\n    SbbOverlayBaseElement.events.didClose,\n  );\n\n  // The last element which had focus before the component was opened.\n  protected lastFocusedElement?: HTMLElement;\n  protected overlayCloseElement?: HTMLElement;\n  protected overlayController!: AbortController;\n  protected openOverlayController!: AbortController;\n  protected focusHandler = new SbbFocusHandler();\n  protected scrollHandler = new SbbScrollHandler();\n  protected returnValue: any;\n  protected ariaLiveRefToggle = false;\n  protected ariaLiveRef!: SbbScreenReaderOnlyElement;\n  protected language = new SbbLanguageController(this);\n\n  protected abstract onOverlayAnimationEnd(event: AnimationEvent): void;\n  protected abstract setOverlayFocus(): void;\n  protected abstract closeAttribute: string;\n\n  /** Closes the component. */\n  public close(result?: any, target?: HTMLElement): any {\n    if (this.state !== 'opened') {\n      return;\n    }\n\n    this.returnValue = result;\n    this.overlayCloseElement = target;\n    const eventData: SbbOverlayCloseEventDetails = {\n      returnValue: this.returnValue,\n      closeTarget: this.overlayCloseElement,\n    };\n\n    if (!this.willClose.emit(eventData)) {\n      return;\n    }\n    this.state = 'closing';\n    this.removeAriaLiveRefContent();\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.overlayController?.abort();\n    this.overlayController = new AbortController();\n\n    if (this.state === 'opened') {\n      applyInertMechanism(this);\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    this.ariaLiveRef =\n      this.shadowRoot!.querySelector<SbbScreenReaderOnlyElement>('sbb-screen-reader-only')!;\n\n    super.firstUpdated(changedProperties);\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this.overlayController?.abort();\n    this.openOverlayController?.abort();\n    this.focusHandler.disconnect();\n    this.removeInstanceFromGlobalCollection();\n    removeInertMechanism();\n  }\n\n  protected attachOpenOverlayEvents(): void {\n    this.openOverlayController = new AbortController();\n    // Remove overlay label as soon as it is not needed any more to prevent accessing it with browse mode.\n    window.addEventListener(\n      'keydown',\n      (event: KeyboardEvent) => {\n        this.removeAriaLiveRefContent();\n        this.onKeydownEvent(event);\n      },\n      {\n        signal: this.openOverlayController.signal,\n      },\n    );\n    window.addEventListener('click', () => this.removeAriaLiveRefContent(), {\n      signal: this.openOverlayController.signal,\n    });\n  }\n\n  protected onKeydownEvent(event: KeyboardEvent): void {\n    if (this.state !== 'opened') {\n      return;\n    }\n\n    if (event.key === 'Escape') {\n      overlayRefs[overlayRefs.length - 1].close();\n      return;\n    }\n  }\n\n  protected removeInstanceFromGlobalCollection(): void {\n    overlayRefs.splice(overlayRefs.indexOf(this as SbbOverlayBaseElement), 1);\n  }\n\n  // Close the component on click of any element that has the `closeAttribute` attribute.\n  protected closeOnSbbOverlayCloseClick(event: Event): void {\n    const overlayCloseElement = event\n      .composedPath()\n      .filter((e): e is HTMLElement => e instanceof window.HTMLElement)\n      .find(\n        (target) => target.hasAttribute(this.closeAttribute) && !target.hasAttribute('disabled'),\n      );\n\n    if (!overlayCloseElement) {\n      return;\n    }\n\n    // Check if the target is a submission element within a form and return the form, if present\n    const closestForm =\n      overlayCloseElement.getAttribute('type') === 'submit'\n        ? (hostContext('form', overlayCloseElement) as HTMLFormElement)\n        : undefined;\n    overlayRefs[overlayRefs.length - 1].close(closestForm, overlayCloseElement);\n  }\n\n  protected removeAriaLiveRefContent(): void {\n    this.ariaLiveRef.textContent = '';\n  }\n\n  protected setAriaLiveRefContent(label?: string): void {\n    this.ariaLiveRefToggle = !this.ariaLiveRefToggle;\n\n    // If the text content remains the same, on VoiceOver the aria-live region is not announced a second time.\n    // In order to support reading on every opening, we toggle an invisible space.\n    this.ariaLiveRef.textContent = `${i18nDialog[this.language.current]}${\n      label ? `, ${label}` : ''\n    }${this.ariaLiveRefToggle ? ' ' : ''}`;\n  }\n}\n","import type { CSSResultGroup, TemplateResult } from 'lit';\nimport { nothing } from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\nimport { html, unsafeStatic } from 'lit/static-html.js';\n\nimport { getFirstFocusableElement, setModalityOnNextFocus } from '../core/a11y.js';\nimport { EventEmitter } from '../core/eventing.js';\nimport { i18nCloseDialog, i18nGoBack } from '../core/i18n.js';\nimport { applyInertMechanism, removeInertMechanism } from '../core/overlay.js';\n\nimport { overlayRefs, SbbOverlayBaseElement } from './overlay-base-element.js';\nimport style from './overlay.scss?lit&inline';\nimport '../button/secondary-button.js';\nimport '../button/transparent-button.js';\nimport '../container.js';\nimport '../screen-reader-only.js';\n\n/**\n * It displays an interactive overlay element.\n *\n * @slot - Use the unnamed slot to provide a content for the overlay.\n * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-overlay` starts the opening transition. Can be canceled.\n * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-overlay` is opened.\n * @event {CustomEvent<void>} willClose - Emits whenever the `sbb-overlay` begins the closing transition. Can be canceled.\n * @event {CustomEvent<SbbOverlayCloseEventDetails>} didClose - Emits whenever the `sbb-overlay` is closed.\n * @event {CustomEvent<void>} requestBackAction - Emits whenever the back button is clicked.\n * @cssprop [--sbb-overlay-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-overlay')\nexport class SbbOverlayElement extends SbbOverlayBaseElement {\n  public static override styles: CSSResultGroup = style;\n\n  // FIXME using ...super.events requires: https://github.com/sbb-design-systems/lyne-components/issues/2600\n  public static override readonly events = {\n    willOpen: 'willOpen',\n    didOpen: 'didOpen',\n    willClose: 'willClose',\n    didClose: 'didClose',\n    backClick: 'requestBackAction',\n  } as const;\n\n  /**\n   * Whether to allow the overlay content to stretch to full width.\n   * By default, the content has the appropriate page size.\n   */\n  @property({ reflect: true, type: Boolean }) public expanded = false;\n\n  /** Whether a back button is displayed next to the title. */\n  @property({ attribute: 'back-button', type: Boolean }) public backButton = false;\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  /** This will be forwarded as aria-label to the back button element. */\n  @property({ attribute: 'accessibility-back-label' }) public accessibilityBackLabel:\n    | string\n    | undefined;\n\n  protected closeAttribute: string = 'sbb-overlay-close';\n\n  /** Emits whenever the back button is clicked. */\n  private _backClick: EventEmitter<any> = new EventEmitter(\n    this,\n    SbbOverlayElement.events.backClick,\n  );\n  private _overlayContentElement: HTMLElement | null = null;\n\n  /** Opens the component. */\n  public open(): void {\n    if (this.state !== 'closed') {\n      return;\n    }\n    this.lastFocusedElement = document.activeElement as HTMLElement;\n\n    this._overlayContentElement = this.shadowRoot?.querySelector(\n      '.sbb-overlay__content',\n    ) as HTMLElement;\n\n    if (!this.willOpen.emit()) {\n      return;\n    }\n    this.state = 'opening';\n\n    // Add this overlay to the global collection\n    overlayRefs.push(this as SbbOverlayElement);\n\n    // Disable scrolling for content below the overlay\n    this.scrollHandler.disableScroll();\n  }\n\n  // Wait for overlay transition to complete.\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  protected onOverlayAnimationEnd(event: AnimationEvent): void {\n    if (event.animationName === 'open' && this.state === 'opening') {\n      this.state = 'opened';\n      this.didOpen.emit();\n      applyInertMechanism(this);\n      this.attachOpenOverlayEvents();\n      this.setOverlayFocus();\n      // Use timeout to read label after focused element\n      setTimeout(() => this.setAriaLiveRefContent(this.accessibilityLabel));\n      this.focusHandler.trap(this);\n    } else if (event.animationName === 'close' && this.state === 'closing') {\n      this._overlayContentElement?.scrollTo(0, 0);\n      this.state = 'closed';\n      removeInertMechanism();\n      setModalityOnNextFocus(this.lastFocusedElement);\n      // Manually focus last focused element\n      this.lastFocusedElement?.focus();\n      this.openOverlayController?.abort();\n      this.focusHandler.disconnect();\n      this.removeInstanceFromGlobalCollection();\n      // Enable scrolling for content below the overlay if no overlay is open\n      !overlayRefs.length && this.scrollHandler.enableScroll();\n      this.didClose.emit({\n        returnValue: this.returnValue,\n        closeTarget: this.overlayCloseElement,\n      });\n    }\n  }\n\n  // Set focus on the first focusable element.\n  protected setOverlayFocus(): void {\n    const firstFocusable = getFirstFocusableElement(\n      Array.from(this.shadowRoot!.children).filter(\n        (e): e is HTMLElement => e instanceof window.HTMLElement,\n      ),\n    );\n    setModalityOnNextFocus(firstFocusable);\n    firstFocusable?.focus();\n  }\n\n  protected override render(): TemplateResult {\n    const TAG_NAME = this.negative ? 'sbb-transparent-button' : 'sbb-secondary-button';\n\n    /* eslint-disable lit/binding-positions */\n    const closeButton = html`\n      <${unsafeStatic(TAG_NAME)}\n        class=\"sbb-overlay__close\"\n        aria-label=${this.accessibilityCloseLabel || i18nCloseDialog[this.language.current]}\n        ?negative=${this.negative}\n        size=\"m\"\n        type=\"button\"\n        icon-name=\"cross-small\"\n        sbb-overlay-close\n      ></${unsafeStatic(TAG_NAME)}>\n    `;\n\n    const backButton = html`\n      <${unsafeStatic(TAG_NAME)}\n        class=\"sbb-overlay__back\"\n        aria-label=${this.accessibilityBackLabel || i18nGoBack[this.language.current]}\n        ?negative=${this.negative}\n        size=\"m\"\n        type=\"button\"\n        icon-name=\"chevron-small-left-small\"\n        @click=${() => this._backClick.emit()}\n      ></${unsafeStatic(TAG_NAME)}>\n    `;\n    /* eslint-enable lit/binding-positions */\n\n    return html`\n      <div class=\"sbb-overlay__container\">\n        <div\n          @animationend=${(event: AnimationEvent) => this.onOverlayAnimationEnd(event)}\n          class=\"sbb-overlay\"\n        >\n          <div\n            @click=${(event: Event) => this.closeOnSbbOverlayCloseClick(event)}\n            class=\"sbb-overlay__wrapper\"\n          >\n            <div class=\"sbb-overlay__header\">\n              ${this.backButton ? backButton : nothing} ${closeButton}\n            </div>\n            <div class=\"sbb-overlay__content\">\n              <sbb-container\n                class=\"sbb-overlay__content-container\"\n                ?expanded=${this.expanded}\n                color=\"transparent\"\n              >\n                <slot></slot>\n              </sbb-container>\n            </div>\n          </div>\n        </div>\n      </div>\n      <sbb-screen-reader-only aria-live=\"polite\"></sbb-screen-reader-only>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-overlay': SbbOverlayElement;\n  }\n}\n"],"names":["_SbbOverlayBaseElement","__decorateClass"],"mappings":"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"}

package/development/popover/popover/popover.d.ts

@@ -0,0 +1,85 @@
+import { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
+import { SbbOpenCloseBaseElement } from '../../core/base-elements.js';
+import { EventEmitter } from '../../core/eventing.js';
+
+/**
+ * It displays contextual information within a popover.
+ *
+ * @slot - Use the unnamed slot to add content into the popover.
+ * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-popover` starts the opening transition. Can be canceled.
+ * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-popover` is opened.
+ * @event {CustomEvent<{ closeTarget: HTMLElement }>} willClose - Emits whenever the `sbb-popover` begins the closing
+ * transition. Can be canceled.
+ * @event {CustomEvent<{ closeTarget: HTMLElement }>} didClose - Emits whenever the `sbb-popover` is closed.
+ * @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`.
+ */
+export declare class SbbPopoverElement extends SbbOpenCloseBaseElement {
+    static styles: CSSResultGroup;
+    /**
+     * The element that will trigger the popover overlay.
+     * Accepts both a string (id of an element) or an HTML element.
+     */
+    trigger?: string | HTMLElement;
+    /** Whether the close button should be hidden. */
+    hideCloseButton?: boolean;
+    /** Whether the popover should be triggered on hover. */
+    hoverTrigger: boolean;
+    /** Open the popover after a certain delay. */
+    openDelay?: number | undefined;
+    /** Close the popover after a certain delay. */
+    closeDelay?: number | undefined;
+    /** This will be forwarded as aria-label to the close button element. */
+    accessibilityCloseLabel: string | undefined;
+    /** Emits whenever the `sbb-popover` begins the closing transition. */
+    protected willClose: EventEmitter<{
+        closeTarget?: HTMLElement;
+    }>;
+    /** Emits whenever the `sbb-popover` is closed. */
+    protected didClose: EventEmitter<{
+        closeTarget?: HTMLElement;
+    }>;
+    private _overlay;
+    private _triggerElement?;
+    private _nextFocusedElement?;
+    private _skipCloseFocus;
+    private _popoverCloseElement?;
+    private _isPointerDownEventOnPopover?;
+    private _popoverController;
+    private _openStateController;
+    private _focusHandler;
+    private _hoverTrigger;
+    private _openTimeout?;
+    private _closeTimeout?;
+    private _language;
+    /** Opens the popover on trigger click. */
+    open(): void;
+    /** Closes the popover. */
+    close(target?: HTMLElement): void;
+    private _onKeydownEvent;
+    private _removeTriggerClickListener;
+    connectedCallback(): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    disconnectedCallback(): void;
+    private _configure;
+    private _attachWindowEvents;
+    private _closeOnSbbPopoverCloseClick;
+    private _pointerDownListener;
+    private _closeOnBackdropClick;
+    private _onTriggerMouseEnter;
+    private _onTriggerMouseLeave;
+    private _onOverlayMouseEnter;
+    private _onOverlayMouseLeave;
+    private _onPopoverAnimationEnd;
+    private _setPopoverFocus;
+    private _setPopoverPosition;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-popover': SbbPopoverElement;
+    }
+}
+//# sourceMappingURL=popover.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"popover.d.ts","sourceRoot":"","sources":["../../../../../src/elements/popover/popover/popover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAW1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAGtE,OAAO,EAA4B,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAYhF,OAAO,kCAAkC,CAAC;AAS1C;;;;;;;;;;;;GAYG;AACH,qBACa,iBAAkB,SAAQ,uBAAuB;IAC5D,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtD;;;OAGG;IACgB,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IAElD,iDAAiD;IACmB,eAAe,CAAC,EAAE,OAAO,CACrF;IAER,wDAAwD;IACQ,YAAY,EAAE,OAAO,CAAS;IAE9F,8CAA8C;IACc,SAAS,CAAC,qBAAK;IAE3E,+CAA+C;IACc,UAAU,CAAC,qBAAK;IAE7E,wEAAwE;IACX,uBAAuB,EAChF,MAAM,GACN,SAAS,CAAC;IAEd,sEAAsE;IACtE,UAAmB,SAAS,EAAE,YAAY,CAAC;QAAE,WAAW,CAAC,EAAE,WAAW,CAAA;KAAE,CAAC,CAGvE;IAEF,kDAAkD;IAClD,UAAmB,QAAQ,EAAE,YAAY,CAAC;QAAE,WAAW,CAAC,EAAE,WAAW,CAAA;KAAE,CAAC,CAGtE;IAEF,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,eAAe,CAAC,CAAqB;IAE7C,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,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,oBAAoB,CAAmB;IAC/C,OAAO,CAAC,aAAa,CAAyB;IAC9C,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,YAAY,CAAC,CAAgC;IACrD,OAAO,CAAC,aAAa,CAAC,CAAgC;IACtD,OAAO,CAAC,SAAS,CAAmC;IAEpD,0CAA0C;IACnC,IAAI,IAAI,IAAI;IAyBnB,0BAA0B;IACnB,KAAK,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI;IAgBxC,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,2BAA2B;IAWnB,iBAAiB,IAAI,IAAI;cAYtB,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;cAYzD,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAS9D,oBAAoB,IAAI,IAAI;IAS5C,OAAO,CAAC,UAAU;IAuDlB,OAAO,CAAC,mBAAmB;IAwB3B,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,oBAAoB,CAE1B;IAGF,OAAO,CAAC,qBAAqB,CAS3B;IAEF,OAAO,CAAC,oBAAoB,CAM1B;IAEF,OAAO,CAAC,oBAAoB,CAM1B;IAEF,OAAO,CAAC,oBAAoB,CAI1B;IAEF,OAAO,CAAC,oBAAoB,CAI1B;IAMF,OAAO,CAAC,sBAAsB;IA8B9B,OAAO,CAAC,gBAAgB;IAyCxB,OAAO,CAAC,mBAAmB;cA6BR,MAAM,IAAI,cAAc;CAkC5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,aAAa,EAAE,iBAAiB,CAAC;KAClC;CACF"}

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

@@ -0,0 +1,21 @@
+import { CSSResultGroup, TemplateResult } from 'lit';
+import { SbbButtonBaseElement } from '../../core/base-elements.js';
+
+declare const SbbPopoverTriggerElement_base: import('../../core/mixins.js').AbstractConstructor<import('../../core/mixins.js').SbbDisabledMixinType> & import('../../core/mixins.js').AbstractConstructor<import('../../core/mixins.js').SbbNegativeMixinType> & import('../../core/mixins.js').AbstractConstructor<import('../../icon.js').SbbIconNameMixinType> & typeof SbbButtonBaseElement;
+/**
+ * It can be used as a trigger for the `sbb-popover` component.
+ *
+ * @slot - Use the unnamed slot to add content to the `sbb-popover-trigger`.
+ */
+export declare class SbbPopoverTriggerElement extends SbbPopoverTriggerElement_base {
+    static styles: CSSResultGroup;
+    connectedCallback(): void;
+    protected renderTemplate(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-popover-trigger': SbbPopoverTriggerElement;
+    }
+}
+export {};
+//# sourceMappingURL=popover-trigger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"popover-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/elements/popover/popover-trigger/popover-trigger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAQ,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;;AAOnE;;;;GAIG;AACH,qBACa,wBAAyB,SAAQ,6BAE7C;IACC,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtC,iBAAiB,IAAI,IAAI;cAUtB,cAAc,IAAI,cAAc;CAOpD;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,qBAAqB,EAAE,wBAAwB,CAAC;KACjD;CACF"}

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

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

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

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