@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/alert/alert-group.js

@@ -0,0 +1,144 @@
+import { css, LitElement, nothing } from "lit";
+import { property, state, customElement } from "lit/decorators.js";
+import { html, unsafeStatic } from "lit/static-html.js";
+import { SbbConnectedAbortController } from "../core/controllers.js";
+import { EventEmitter } from "../core/eventing.js";
+import { SbbHydrationMixin } from "../core/mixins.js";
+import { SbbAlertElement } from "./alert.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-alert-group-gap: var(--sbb-spacing-fixed-3x);
+  --sbb-alert-group-border-radius: var(--sbb-border-radius-4x);
+  display: block;
+}
+
+.sbb-alert-group {
+  display: flex;
+  flex-direction: column;
+  gap: var(--sbb-alert-group-gap);
+}
+
+:host(:focus-visible:not([data-empty])) {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) solid var(--sbb-focus-outline-width);
+  border-radius: var(--sbb-alert-group-border-radius);
+}
+
+.sbb-alert-group__title {
+  border: 0;
+  clip: rect(0 0 0 0);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+  width: 1px;
+}`;
+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 SbbAlertGroupElement = class extends SbbHydrationMixin(LitElement) {
+  constructor() {
+    super(...arguments);
+    this.role = "status";
+    this.accessibilityTitleLevel = "2";
+    this._didDismissAlert = new EventEmitter(
+      this,
+      SbbAlertGroupElement.events.didDismissAlert
+    );
+    this._empty = new EventEmitter(this, SbbAlertGroupElement.events.empty);
+    this._abort = new SbbConnectedAbortController(this);
+  }
+  _removeAlert(event) {
+    var _a;
+    const target = event.target;
+    const hasFocusInsideAlertGroup = document.activeElement === target;
+    (_a = target.parentNode) == null ? void 0 : _a.removeChild(target);
+    this._didDismissAlert.emit(target);
+    if (hasFocusInsideAlertGroup) {
+      this.tabIndex = 0;
+      this.focus();
+      this.addEventListener("blur", () => this.removeAttribute("tabindex"), {
+        once: true
+      });
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const signal = this._abort.signal;
+    this.addEventListener(SbbAlertElement.events.dismissalRequested, (e) => this._removeAlert(e), {
+      signal
+    });
+  }
+  _slotChanged(event) {
+    const hadAlerts = this._hasAlerts;
+    this._hasAlerts = event.target.assignedElements().filter((e) => e instanceof Element && e.localName === "sbb-alert").length > 0;
+    if (!this._hasAlerts && hadAlerts) {
+      this._empty.emit();
+    }
+    this.toggleAttribute("data-empty", !this._hasAlerts);
+  }
+  render() {
+    const TITLE_TAG_NAME = `h${this.accessibilityTitleLevel}`;
+    return html`
+      <div class="sbb-alert-group">
+        ${this._hasAlerts ? html`<${unsafeStatic(TITLE_TAG_NAME)} class="sbb-alert-group__title">
+              <slot name="accessibility-title">${this.accessibilityTitle}</slot>
+            </${unsafeStatic(TITLE_TAG_NAME)}>` : nothing}
+        <slot @slotchange=${(event) => this._slotChanged(event)}></slot>
+      </div>
+    `;
+  }
+};
+SbbAlertGroupElement.styles = style;
+SbbAlertGroupElement.events = {
+  didDismissAlert: "didDismissAlert",
+  empty: "empty"
+};
+__decorateClass([
+  property({ reflect: true })
+], SbbAlertGroupElement.prototype, "role", 2);
+__decorateClass([
+  property({ attribute: "accessibility-title" })
+], SbbAlertGroupElement.prototype, "accessibilityTitle", 2);
+__decorateClass([
+  property({ attribute: "accessibility-title-level" })
+], SbbAlertGroupElement.prototype, "accessibilityTitleLevel", 2);
+__decorateClass([
+  state()
+], SbbAlertGroupElement.prototype, "_hasAlerts", 2);
+SbbAlertGroupElement = __decorateClass([
+  customElement("sbb-alert-group")
+], SbbAlertGroupElement);
+export {
+  SbbAlertGroupElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"alert-group.js","sources":["../../../../src/elements/alert/alert-group/alert-group.ts"],"sourcesContent":["import type { CSSResultGroup, TemplateResult } from 'lit';\nimport { LitElement, nothing } from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\nimport { html, unsafeStatic } from 'lit/static-html.js';\n\nimport { SbbConnectedAbortController } from '../../core/controllers.js';\nimport { EventEmitter } from '../../core/eventing.js';\nimport { SbbHydrationMixin } from '../../core/mixins.js';\nimport type { SbbTitleLevel } from '../../title.js';\nimport { SbbAlertElement } from '../alert.js';\n\nimport style from './alert-group.scss?lit&inline';\n\n/**\n * It can be used as a container for one or more `sbb-alert` component.\n *\n * @slot - Use the unnamed slot to add `sbb-alert` elements to the `sbb-alert-group`.\n * @slot accessibility-title - title for this `sbb-alert-group` which is only visible for screen reader users.\n * @event {CustomEvent<SbbAlertElement>} didDismissAlert - Emits when an alert was removed from DOM.\n * @event {CustomEvent<void>} empty - Emits when `sbb-alert-group` becomes empty.\n */\n@customElement('sbb-alert-group')\nexport class SbbAlertGroupElement extends SbbHydrationMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    didDismissAlert: 'didDismissAlert',\n    empty: 'empty',\n  } as const;\n\n  /**\n   * The role attribute defines how to announce alerts to the user.\n   *\n   * 'status': sets aria-live to polite and aria-atomic to true.\n   * 'alert': sets aria-live to assertive and aria-atomic to true.\n   */\n  @property({ reflect: true })\n  public override role: 'alert' | 'status' | string = 'status';\n\n  /** Title for this alert group which is only visible for screen reader users. */\n  @property({ attribute: 'accessibility-title' }) public accessibilityTitle?: string;\n\n  /** Level of the accessibility title, will be rendered as heading tag (e.g. h2). Defaults to level 2. */\n  @property({ attribute: 'accessibility-title-level' })\n  public accessibilityTitleLevel: SbbTitleLevel = '2';\n\n  /** Whether the group currently has any alerts. */\n  @state() private _hasAlerts?: boolean;\n\n  /** Emits when an alert was removed from DOM. */\n  private _didDismissAlert: EventEmitter<SbbAlertElement> = new EventEmitter(\n    this,\n    SbbAlertGroupElement.events.didDismissAlert,\n  );\n\n  /** Emits when `sbb-alert-group` becomes empty. */\n  private _empty: EventEmitter<void> = new EventEmitter(this, SbbAlertGroupElement.events.empty);\n\n  private _abort = new SbbConnectedAbortController(this);\n\n  private _removeAlert(event: Event): void {\n    const target = event.target as SbbAlertElement;\n    const hasFocusInsideAlertGroup = document.activeElement === target;\n\n    target.parentNode?.removeChild(target);\n    this._didDismissAlert.emit(target);\n\n    // Restore focus\n    if (hasFocusInsideAlertGroup) {\n      // Set tabindex to 0 the make it focusable and afterwards focus it.\n      // This is done to not completely lose focus after removal of an alert.\n      // Once the sbb-alert-group was blurred, make the alert group not focusable again.\n      this.tabIndex = 0;\n      this.focus();\n      this.addEventListener('blur', () => this.removeAttribute('tabindex'), {\n        once: true,\n      });\n    }\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    const signal = this._abort.signal;\n    this.addEventListener(SbbAlertElement.events.dismissalRequested, (e) => this._removeAlert(e), {\n      signal,\n    });\n  }\n\n  private _slotChanged(event: Event): void {\n    const hadAlerts = this._hasAlerts;\n    this._hasAlerts =\n      (event.target as HTMLSlotElement)\n        .assignedElements()\n        .filter((e) => e instanceof Element && e.localName === 'sbb-alert').length > 0;\n    if (!this._hasAlerts && hadAlerts) {\n      this._empty.emit();\n    }\n\n    this.toggleAttribute('data-empty', !this._hasAlerts);\n  }\n\n  protected override render(): TemplateResult {\n    const TITLE_TAG_NAME = `h${this.accessibilityTitleLevel}`;\n\n    /* eslint-disable lit/binding-positions */\n    return html`\n      <div class=\"sbb-alert-group\">\n        ${this._hasAlerts\n          ? html`<${unsafeStatic(TITLE_TAG_NAME)} class=\"sbb-alert-group__title\">\n              <slot name=\"accessibility-title\">${this.accessibilityTitle}</slot>\n            </${unsafeStatic(TITLE_TAG_NAME)}>`\n          : nothing}\n        <slot @slotchange=${(event: Event) => this._slotChanged(event)}></slot>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-alert-group': SbbAlertGroupElement;\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBO,IAAM,uBAAN,cAAmC,kBAAkB,UAAU,EAAE;AAAA,EAAjE,cAAA;AAAA,UAAA,GAAA,SAAA;AAcL,SAAgB,OAAoC;AAOpD,SAAO,0BAAyC;AAMhD,SAAQ,mBAAkD,IAAI;AAAA,MAC5D;AAAA,MACA,qBAAqB,OAAO;AAAA,IAAA;AAI9B,SAAQ,SAA6B,IAAI,aAAa,MAAM,qBAAqB,OAAO,KAAK;AAErF,SAAA,SAAS,IAAI,4BAA4B,IAAI;AAAA,EAAA;AAAA,EAE7C,aAAa,OAAoB;;AACvC,UAAM,SAAS,MAAM;AACf,UAAA,2BAA2B,SAAS,kBAAkB;AAErD,iBAAA,eAAA,mBAAY,YAAY;AAC1B,SAAA,iBAAiB,KAAK,MAAM;AAGjC,QAAI,0BAA0B;AAI5B,WAAK,WAAW;AAChB,WAAK,MAAM;AACX,WAAK,iBAAiB,QAAQ,MAAM,KAAK,gBAAgB,UAAU,GAAG;AAAA,QACpE,MAAM;AAAA,MAAA,CACP;AAAA,IACH;AAAA,EACF;AAAA,EAEgB,oBAA0B;AACxC,UAAM,kBAAkB;AAClB,UAAA,SAAS,KAAK,OAAO;AACtB,SAAA,iBAAiB,gBAAgB,OAAO,oBAAoB,CAAC,MAAM,KAAK,aAAa,CAAC,GAAG;AAAA,MAC5F;AAAA,IAAA,CACD;AAAA,EACH;AAAA,EAEQ,aAAa,OAAoB;AACvC,UAAM,YAAY,KAAK;AACvB,SAAK,aACF,MAAM,OACJ,iBAAA,EACA,OAAO,CAAC,MAAM,aAAa,WAAW,EAAE,cAAc,WAAW,EAAE,SAAS;AAC7E,QAAA,CAAC,KAAK,cAAc,WAAW;AACjC,WAAK,OAAO;IACd;AAEA,SAAK,gBAAgB,cAAc,CAAC,KAAK,UAAU;AAAA,EACrD;AAAA,EAEmB,SAAyB;AACpC,UAAA,iBAAiB,IAAI,KAAK,uBAAuB;AAGhD,WAAA;AAAA;AAAA,UAED,KAAK,aACH,QAAQ,aAAa,cAAc,CAAC;AAAA,iDACC,KAAK,kBAAkB;AAAA,gBACxD,aAAa,cAAc,CAAC,MAChC,OAAO;AAAA,4BACS,CAAC,UAAiB,KAAK,aAAa,KAAK,CAAC;AAAA;AAAA;AAAA,EAGpE;AACF;AA7Fa,qBACY,SAAyB;AADrC,qBAEY,SAAS;AAAA,EAC9B,iBAAiB;AAAA,EACjB,OAAO;AACT;AASgB,gBAAA;AAAA,EADf,SAAS,EAAE,SAAS,MAAM;AAAA,GAbhB,qBAcK,WAAA,QAAA,CAAA;AAGuC,gBAAA;AAAA,EAAtD,SAAS,EAAE,WAAW,uBAAuB;AAAA,GAjBnC,qBAiB4C,WAAA,sBAAA,CAAA;AAIhD,gBAAA;AAAA,EADN,SAAS,EAAE,WAAW,6BAA6B;AAAA,GApBzC,qBAqBJ,WAAA,2BAAA,CAAA;AAGU,gBAAA;AAAA,EAAhB,MAAM;AAAA,GAxBI,qBAwBM,WAAA,cAAA,CAAA;AAxBN,uBAAN,gBAAA;AAAA,EADN,cAAc,iBAAiB;AAAA,GACnB,oBAAA;"}

package/development/alert/alert.d.ts

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

package/development/alert/alert.d.ts.map

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

package/development/alert/alert.js

@@ -0,0 +1,342 @@
+import { css, LitElement, html, nothing } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { SbbLanguageController } from "../core/controllers.js";
+import { EventEmitter } from "../core/eventing.js";
+import { i18nFindOutMore, i18nCloseAlert } from "../core/i18n.js";
+import { SbbIconNameMixin } from "../icon.js";
+import "../button/transparent-button.js";
+import "../divider.js";
+import "../link.js";
+import "../title.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-focus-outline-color: var(--sbb-focus-outline-color-dark);
+  --sbb-alert-background-color: var(--sbb-color-midnight);
+  --sbb-alert-border-radius: var(--sbb-border-radius-4x);
+  --sbb-alert-color: var(--sbb-color-aluminium);
+  --sbb-alert-padding: var(--sbb-spacing-responsive-xxs) var(--sbb-spacing-responsive-xs);
+  --sbb-alert-icon-size: 1.25rem;
+  --sbb-alert-close-icon-size: var(--sbb-size-icon-ui-small);
+  --sbb-alert-close-icon-margin: var(--sbb-spacing-responsive-xxs);
+  --sbb-alert-gap: var(--sbb-spacing-fixed-2x) var(--sbb-spacing-responsive-xs);
+  --sbb-alert-animation-duration: var(
+    --sbb-disable-animation-zero-time,
+    var(--sbb-animation-duration-6x)
+  );
+  display: block;
+}
+@media (min-width: calc(52.5rem)) {
+  :host {
+    --sbb-alert-icon-size: 1.75rem;
+  }
+}
+@media (forced-colors: active) {
+  :host {
+    outline: var(--sbb-border-width-1x) solid CanvasText;
+    border-radius: var(--sbb-alert-border-radius);
+  }
+}
+
+:host([animation=none]) {
+  --sbb-disable-animation-time: 0.1ms;
+  --sbb-disable-animation-zero-time: 0s;
+}
+
+:host([size=s]) {
+  --sbb-alert-gap: var(--sbb-spacing-fixed-1x) var(--sbb-spacing-responsive-xxs);
+  --sbb-alert-close-icon-margin: var(--sbb-spacing-responsive-xxxs);
+}
+
+:host([size=l]) {
+  --sbb-alert-icon-size: var(--sbb-size-icon-ui-small);
+}
+@media (min-width: calc(52.5rem)) {
+  :host([size=l]) {
+    --sbb-alert-icon-size: 2.125rem;
+  }
+}
+
+.sbb-alert__transition-wrapper {
+  display: grid;
+  grid-template-rows: 0fr;
+  opacity: 0;
+}
+:host([data-state=opened]) .sbb-alert__transition-wrapper {
+  grid-template-rows: 1fr;
+  opacity: 1;
+}
+:host([data-state=opening]) .sbb-alert__transition-wrapper {
+  animation-name: open, open-opacity;
+  animation-fill-mode: forwards;
+  animation-duration: var(--sbb-alert-animation-duration);
+  animation-timing-function: ease-in;
+  animation-delay: 0s, var(--sbb-alert-animation-duration);
+}
+
+.sbb-alert__transition-sub-wrapper {
+  overflow: hidden;
+}
+
+.sbb-alert {
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  display: grid;
+  grid-template-columns: 1fr auto;
+  align-items: center;
+  gap: var(--sbb-alert-gap);
+  min-width: fit-content;
+  padding: var(--sbb-alert-padding);
+  overflow: hidden;
+  color: var(--sbb-alert-color);
+  background-color: var(--sbb-alert-background-color);
+  border-radius: var(--sbb-alert-border-radius);
+}
+@media (min-width: calc(37.5rem)) {
+  .sbb-alert {
+    grid-template-columns: auto 1fr auto;
+    align-items: flex-start;
+  }
+}
+
+.sbb-alert__icon {
+  display: flex;
+  align-items: start;
+  padding-block: var(--sbb-spacing-fixed-1x);
+  min-width: var(--sbb-alert-icon-size);
+  --sbb-icon-svg-width: var(--sbb-alert-icon-size);
+  --sbb-icon-svg-height: var(--sbb-alert-icon-size);
+}
+
+.sbb-alert__content {
+  order: 3;
+  grid-column: 1/3;
+}
+@media (min-width: calc(37.5rem)) {
+  .sbb-alert__content {
+    order: initial;
+    grid-column-start: initial;
+    grid-column-end: initial;
+  }
+}
+
+.sbb-alert__content-slot {
+  display: inline;
+  margin: 0;
+  padding: 0;
+}
+
+.sbb-alert__title {
+  margin: 0;
+}
+
+.sbb-alert__close-button-wrapper {
+  display: flex;
+  justify-content: flex-end;
+  align-items: center;
+  height: 100%;
+}
+
+@media (min-width: calc(37.5rem)) {
+  .sbb-alert__close-button {
+    margin-inline-start: var(--sbb-alert-close-icon-margin);
+  }
+}
+
+.sbb-alert__close-button-divider {
+  display: none;
+}
+@media (min-width: calc(37.5rem)) {
+  .sbb-alert__close-button-divider {
+    display: block;
+    height: calc(100% - var(--sbb-spacing-fixed-1x) * 2);
+  }
+}
+
+@keyframes open {
+  from {
+    grid-template-rows: 0fr;
+  }
+  to {
+    grid-template-rows: 1fr;
+  }
+}
+@keyframes open-opacity {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
+}`;
+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 SbbAlertElement = class extends SbbIconNameMixin(LitElement) {
+  constructor() {
+    super(...arguments);
+    this.readonly = false;
+    this.size = "m";
+    this.iconName = "info";
+    this.titleLevel = "3";
+    this.animation = "open";
+    this._willOpen = new EventEmitter(this, SbbAlertElement.events.willOpen);
+    this._didOpen = new EventEmitter(this, SbbAlertElement.events.didOpen);
+    this._dismissalRequested = new EventEmitter(
+      this,
+      SbbAlertElement.events.dismissalRequested
+    );
+    this._language = new SbbLanguageController(this);
+  }
+  /** The state of the alert. */
+  get _state() {
+    return this.getAttribute("data-state") ?? "closed";
+  }
+  set _state(value) {
+    this.setAttribute("data-state", value);
+  }
+  async firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    this._open();
+  }
+  /** Requests dismissal of the alert. */
+  requestDismissal() {
+    this._dismissalRequested.emit();
+  }
+  /** Open the alert. */
+  _open() {
+    this._state = "opening";
+    this._willOpen.emit();
+  }
+  _onAnimationEnd(event) {
+    if (this._state === "opening" && event.animationName === "open-opacity") {
+      this._state = "opened";
+      this._didOpen.emit();
+    }
+  }
+  render() {
+    return html`
+      <div class="sbb-alert__transition-wrapper" @animationend=${this._onAnimationEnd}>
+        <!-- sub wrapper needed to properly support fade in animation -->
+        <div class="sbb-alert__transition-sub-wrapper">
+          <div class="sbb-alert">
+            <span class="sbb-alert__icon"> ${this.renderIconSlot()} </span>
+            <span class="sbb-alert__content">
+              <sbb-title
+                class="sbb-alert__title"
+                level=${this.titleLevel}
+                visual-level=${this.size === "l" ? "3" : "5"}
+                negative
+              >
+                <slot name="title">${this.titleContent}</slot>
+              </sbb-title>
+              <p class="sbb-alert__content-slot">
+                <slot></slot>
+              </p>
+              ${this.href ? html` <sbb-link
+                    accessibility-label=${this.accessibilityLabel ?? nothing}
+                    href=${this.href ?? nothing}
+                    target=${this.target ?? nothing}
+                    rel=${this.rel ?? nothing}
+                    negative
+                  >
+                    ${this.linkContent ? this.linkContent : i18nFindOutMore[this._language.current]}
+                  </sbb-link>` : nothing}
+            </span>
+            ${!this.readonly ? html`<span class="sbb-alert__close-button-wrapper">
+                  <sbb-divider
+                    orientation="vertical"
+                    negative
+                    class="sbb-alert__close-button-divider"
+                  ></sbb-divider>
+                  <sbb-transparent-button
+                    negative
+                    size=${this.size === "l" ? "m" : this.size}
+                    icon-name="cross-small"
+                    @click=${() => this.requestDismissal()}
+                    aria-label=${i18nCloseAlert[this._language.current]}
+                    class="sbb-alert__close-button"
+                  ></sbb-transparent-button>
+                </span>` : nothing}
+          </div>
+        </div>
+      </div>
+    `;
+  }
+};
+SbbAlertElement.styles = style;
+SbbAlertElement.events = {
+  willOpen: "willOpen",
+  didOpen: "didOpen",
+  dismissalRequested: "dismissalRequested"
+};
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbAlertElement.prototype, "readonly", 2);
+__decorateClass([
+  property({ reflect: true })
+], SbbAlertElement.prototype, "size", 2);
+__decorateClass([
+  property({ attribute: "icon-name" })
+], SbbAlertElement.prototype, "iconName", 2);
+__decorateClass([
+  property({ attribute: "title-content" })
+], SbbAlertElement.prototype, "titleContent", 2);
+__decorateClass([
+  property({ attribute: "title-level" })
+], SbbAlertElement.prototype, "titleLevel", 2);
+__decorateClass([
+  property({ attribute: "link-content" })
+], SbbAlertElement.prototype, "linkContent", 2);
+__decorateClass([
+  property()
+], SbbAlertElement.prototype, "href", 2);
+__decorateClass([
+  property()
+], SbbAlertElement.prototype, "target", 2);
+__decorateClass([
+  property()
+], SbbAlertElement.prototype, "rel", 2);
+__decorateClass([
+  property({ attribute: "accessibility-label" })
+], SbbAlertElement.prototype, "accessibilityLabel", 2);
+__decorateClass([
+  property({ reflect: true })
+], SbbAlertElement.prototype, "animation", 2);
+SbbAlertElement = __decorateClass([
+  customElement("sbb-alert")
+], SbbAlertElement);
+export {
+  SbbAlertElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"alert.js","sources":["../../../../src/elements/alert/alert/alert.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  LitElement,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\n\nimport type { LinkTargetType } from '../../core/base-elements.js';\nimport { SbbLanguageController } from '../../core/controllers.js';\nimport { EventEmitter } from '../../core/eventing.js';\nimport { i18nCloseAlert, i18nFindOutMore } from '../../core/i18n.js';\nimport type { SbbOpenedClosedState } from '../../core/interfaces.js';\nimport { SbbIconNameMixin } from '../../icon.js';\nimport type { SbbTitleLevel } from '../../title.js';\n\nimport style from './alert.scss?lit&inline';\n\nimport '../../button/transparent-button.js';\nimport '../../divider.js';\nimport '../../link.js';\nimport '../../title.js';\n\ntype SbbAlertState = Exclude<SbbOpenedClosedState, 'closing'>;\n\n/**\n * It displays messages which require user's attention.\n *\n * @slot - Use the unnamed slot to add content to the `sbb-alert`.\n * @slot icon - Should be a `sbb-icon` which is displayed next to the title. Styling is optimized for icons of type HIM-CUS.\n * @slot title - Title content.\n * @event {CustomEvent<void>} willOpen - Emits when the fade in animation starts.\n * @event {CustomEvent<void>} didOpen - Emits when the fade in animation ends and the button is displayed.\n * @event {CustomEvent<void>} dismissalRequested - Emits when dismissal of an alert was requested.\n */\n@customElement('sbb-alert')\nexport class SbbAlertElement extends SbbIconNameMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    willOpen: 'willOpen',\n    didOpen: 'didOpen',\n    dismissalRequested: 'dismissalRequested',\n  } as const;\n\n  /**\n   * Whether the alert is readonly.\n   * In readonly mode, there is no dismiss button offered to the user.\n   */\n  @property({ reflect: true, type: Boolean }) public readonly = false;\n\n  /** You can choose between `m` or `l` size. */\n  @property({ reflect: true }) public size: 's' | 'm' | 'l' = 'm';\n\n  /**\n   * Name of the icon which will be forward to the nested `sbb-icon`.\n   * Choose the icons from https://icons.app.sbb.ch.\n   * Styling is optimized for icons of type HIM-CUS.\n   */\n  @property({ attribute: 'icon-name' }) public override iconName: string = 'info';\n\n  /** Content of title. */\n  @property({ attribute: 'title-content' }) public titleContent?: string;\n\n  /** Level of title, will be rendered as heading tag (e.g. h3). Defaults to level 3. */\n  @property({ attribute: 'title-level' }) public titleLevel: SbbTitleLevel = '3';\n\n  /** Content of the link. */\n  @property({ attribute: 'link-content' }) public linkContent?: string;\n\n  /** The href value you want to link to. */\n  @property() public href: string | undefined;\n\n  /** Where to display the linked URL. */\n  @property() public target: LinkTargetType | string | undefined;\n\n  /** The relationship of the linked URL as space-separated link types. */\n  @property() public rel: string | undefined;\n\n  /** This will be forwarded as aria-label to the relevant nested element. */\n  @property({ attribute: 'accessibility-label' }) public accessibilityLabel: string | undefined;\n\n  /** The enabled animations. */\n  @property({ reflect: true }) public animation: 'open' | 'none' = 'open';\n\n  /** The state of the alert. */\n  private get _state(): SbbAlertState {\n    return (this.getAttribute('data-state') as SbbAlertState | null) ?? 'closed';\n  }\n  private set _state(value: SbbAlertState) {\n    this.setAttribute('data-state', value);\n  }\n\n  /** Emits when the fade in animation starts. */\n  private _willOpen: EventEmitter<void> = new EventEmitter(this, SbbAlertElement.events.willOpen);\n\n  /** Emits when the fade in animation ends and the button is displayed. */\n  private _didOpen: EventEmitter<void> = new EventEmitter(this, SbbAlertElement.events.didOpen);\n\n  /** Emits when dismissal of an alert was requested. */\n  private _dismissalRequested: EventEmitter<void> = new EventEmitter(\n    this,\n    SbbAlertElement.events.dismissalRequested,\n  );\n\n  private _language = new SbbLanguageController(this);\n\n  protected override async firstUpdated(changedProperties: PropertyValues<this>): Promise<void> {\n    super.firstUpdated(changedProperties);\n\n    this._open();\n  }\n\n  /** Requests dismissal of the alert. */\n  public requestDismissal(): void {\n    this._dismissalRequested.emit();\n  }\n\n  /** Open the alert. */\n  private _open(): void {\n    this._state = 'opening';\n    this._willOpen.emit();\n  }\n\n  private _onAnimationEnd(event: AnimationEvent): void {\n    if (this._state === 'opening' && event.animationName === 'open-opacity') {\n      this._state = 'opened';\n      this._didOpen.emit();\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-alert__transition-wrapper\" @animationend=${this._onAnimationEnd}>\n        <!-- sub wrapper needed to properly support fade in animation -->\n        <div class=\"sbb-alert__transition-sub-wrapper\">\n          <div class=\"sbb-alert\">\n            <span class=\"sbb-alert__icon\"> ${this.renderIconSlot()} </span>\n            <span class=\"sbb-alert__content\">\n              <sbb-title\n                class=\"sbb-alert__title\"\n                level=${this.titleLevel}\n                visual-level=${this.size === 'l' ? '3' : '5'}\n                negative\n              >\n                <slot name=\"title\">${this.titleContent}</slot>\n              </sbb-title>\n              <p class=\"sbb-alert__content-slot\">\n                <slot></slot>\n              </p>\n              ${this.href\n                ? html` <sbb-link\n                    accessibility-label=${this.accessibilityLabel ?? nothing}\n                    href=${this.href ?? nothing}\n                    target=${this.target ?? nothing}\n                    rel=${this.rel ?? nothing}\n                    negative\n                  >\n                    ${this.linkContent ? this.linkContent : i18nFindOutMore[this._language.current]}\n                  </sbb-link>`\n                : nothing}\n            </span>\n            ${!this.readonly\n              ? html`<span class=\"sbb-alert__close-button-wrapper\">\n                  <sbb-divider\n                    orientation=\"vertical\"\n                    negative\n                    class=\"sbb-alert__close-button-divider\"\n                  ></sbb-divider>\n                  <sbb-transparent-button\n                    negative\n                    size=${this.size === 'l' ? 'm' : this.size}\n                    icon-name=\"cross-small\"\n                    @click=${() => this.requestDismissal()}\n                    aria-label=${i18nCloseAlert[this._language.current]}\n                    class=\"sbb-alert__close-button\"\n                  ></sbb-transparent-button>\n                </span>`\n              : nothing}\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-alert': SbbAlertElement;\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/alert.d.ts

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

package/development/alert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alert.d.ts","sourceRoot":"","sources":["../../../src/elements/alert.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC"}

package/development/alert.js

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

package/development/autocomplete/autocomplete.d.ts

@@ -0,0 +1,108 @@
+import { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
+import { SbbOpenCloseBaseElement } from '../core/base-elements.js';
+
+declare const SbbAutocompleteElement_base: import('../core/mixins.js').AbstractConstructor<import('../core/mixins.js').SbbNegativeMixinType> & import('../core/mixins.js').AbstractConstructor<import('../core/mixins.js').SbbHydrationMixinType> & typeof SbbOpenCloseBaseElement;
+/**
+ * Combined with a native input, it displays a panel with a list of available options.
+ *
+ * @slot - Use the unnamed slot to add `sbb-option` or `sbb-optgroup` elements to the `sbb-autocomplete`.
+ * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-autocomplete` starts the opening transition. Can be canceled.
+ * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-autocomplete` is opened.
+ * @event {CustomEvent<void>} willClose - Emits whenever the `sbb-autocomplete` begins the closing transition. Can be canceled.
+ * @event {CustomEvent<void>} didClose - Emits whenever the `sbb-autocomplete` is closed.
+ * @cssprop [--sbb-autocomplete-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 SbbAutocompleteElement extends SbbAutocompleteElement_base {
+    static styles: CSSResultGroup;
+    /**
+     * The element where the autocomplete will attach; accepts both an element's id or an HTMLElement.
+     * If not set, will search for the first 'sbb-form-field' ancestor.
+     */
+    origin?: string | HTMLElement;
+    /**
+     * The input element that will trigger the autocomplete opening; accepts both an element's id or an HTMLElement.
+     * By default, the autocomplete will open on focus, click, input or `ArrowDown` keypress of the 'trigger' element.
+     * If not set, will search for the first 'input' child of a 'sbb-form-field' ancestor.
+     */
+    trigger?: string | HTMLInputElement;
+    /** Whether the icon space is preserved when no icon is set. */
+    preserveIconSpace?: boolean;
+    private _overlay;
+    private _optionContainer;
+    /** Returns the element where autocomplete overlay is attached to. */
+    get originElement(): HTMLElement;
+    private _originElement?;
+    /** Returns the trigger element. */
+    get triggerElement(): HTMLInputElement | undefined;
+    private _triggerElement;
+    private _triggerEventsController;
+    private _openPanelEventsController;
+    private _overlayId;
+    private _activeItemIndex;
+    private _didLoad;
+    private _isPointerDownEventOnMenu;
+    private _abort;
+    /** The autocomplete should inherit 'readonly' state from the trigger. */
+    private get _readonly();
+    private get _options();
+    /** Opens the autocomplete. */
+    open(): void;
+    /** Closes the autocomplete. */
+    close(): void;
+    /** Removes trigger click listener on trigger change. */
+    private _resetOriginClickListener;
+    /** Removes trigger click listener on trigger change. */
+    private _resetTriggerClickListener;
+    /** When an option is selected, update the input value and close the autocomplete. */
+    private _onOptionSelected;
+    private _onOptionClick;
+    connectedCallback(): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    private _syncNegative;
+    disconnectedCallback(): void;
+    private _componentSetup;
+    /**
+     * Retrieve the element where the autocomplete will be attached.
+     * @returns 'origin' or the first 'sbb-form-field' ancestor.
+     */
+    private _findOriginElement;
+    /**
+     * Retrieve the element that will trigger the autocomplete opening.
+     * @returns 'trigger' or the first 'input' inside the origin element.
+     */
+    private _getTriggerElement;
+    private _bindTo;
+    private _setupTriggerEvents;
+    private _setOverlayPosition;
+    /** On open/close animation end.
+     *  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.
+     */
+    private _onAnimationEnd;
+    private _onOpenAnimationEnd;
+    private _onCloseAnimationEnd;
+    private _attachOpenPanelEvents;
+    private _pointerDownListener;
+    private _closeOnBackdropClick;
+    private _closedPanelKeyboardInteraction;
+    private _openedPanelKeyboardInteraction;
+    private _selectByKeyboard;
+    private _setNextActiveOption;
+    private _resetActiveElement;
+    /** Highlight the searched text on the options. */
+    private _highlightOptions;
+    private _setTriggerAttributes;
+    private _removeTriggerAttributes;
+    private _handleSlotchange;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-autocomplete': SbbAutocompleteElement;
+    }
+}
+export {};
+//# sourceMappingURL=autocomplete.d.ts.map

package/development/autocomplete/autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../../../src/elements/autocomplete/autocomplete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAM1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;;AAwBnE;;;;;;;;;;;GAWG;AACH,qBAKa,sBAAuB,SAAQ,2BAE3C;IACC,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtD;;;OAGG;IACgB,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IAEjD;;;;OAIG;IACgB,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;IAEvD,+DAA+D;IAExD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAEnC,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,gBAAgB,CAAe;IAEvC,qEAAqE;IACrE,IAAW,aAAa,IAAI,WAAW,CAKtC;IACD,OAAO,CAAC,cAAc,CAAC,CAAc;IAErC,mCAAmC;IACnC,IAAW,cAAc,IAAI,gBAAgB,GAAG,SAAS,CAExD;IACD,OAAO,CAAC,eAAe,CAA+B;IAEtD,OAAO,CAAC,wBAAwB,CAAmB;IACnD,OAAO,CAAC,0BAA0B,CAAmB;IACrD,OAAO,CAAC,UAAU,CAAkC;IACpD,OAAO,CAAC,gBAAgB,CAAM;IAC9B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,yBAAyB,CAAkB;IACnD,OAAO,CAAC,MAAM,CAAyC;IAEvD,yEAAyE;IACzE,OAAO,KAAK,SAAS,GAEpB;IAED,OAAO,KAAK,QAAQ,GAEnB;IAED,8BAA8B;IACvB,IAAI,IAAI,IAAI;IAYnB,+BAA+B;IACxB,KAAK,IAAI,IAAI;IAYpB,wDAAwD;IACxD,OAAO,CAAC,yBAAyB;IASjC,wDAAwD;IACxD,OAAO,CAAC,0BAA0B;IASlC,qFAAqF;IACrF,OAAO,CAAC,iBAAiB;IAuBzB,OAAO,CAAC,cAAc;IAUN,iBAAiB,IAAI,IAAI;cA0BtB,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;cAczD,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAM9E,OAAO,CAAC,aAAa;IAQL,oBAAoB,IAAI,IAAI;IAM5C,OAAO,CAAC,eAAe;IAgBvB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAkB1B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,OAAO;IAcf,OAAO,CAAC,mBAAmB;IA0B3B,OAAO,CAAC,mBAAmB;IAU3B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,sBAAsB;IAgC9B,OAAO,CAAC,oBAAoB,CAE1B;IAGF,OAAO,CAAC,qBAAqB,CAQ3B;IAEF,OAAO,CAAC,+BAA+B;IAcvC,OAAO,CAAC,+BAA+B;IAsBvC,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,oBAAoB;IAqB5B,OAAO,CAAC,mBAAmB;IAU3B,kDAAkD;IAClD,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,wBAAwB;IAIhC,OAAO,CAAC,iBAAiB;cAIN,MAAM,IAAI,cAAc;CAwB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,kBAAkB,EAAE,sBAAsB,CAAC;KAC5C;CACF"}

package/development/autocomplete.d.ts

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

package/development/autocomplete.d.ts.map

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