@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/form-field/form-field.js

@@ -0,0 +1,885 @@
+import { css, LitElement, html, nothing } from "lit";
+import { property, state, customElement } from "lit/decorators.js";
+import { sbbInputModalityDetector } from "../core/a11y.js";
+import { SbbConnectedAbortController, SbbLanguageController, SbbSlotStateController } from "../core/controllers.js";
+import { isFirefox, setOrRemoveAttribute } from "../core/dom.js";
+import { i18nOptional } from "../core/i18n.js";
+import { SbbNegativeMixin } from "../core/mixins.js";
+import { AgnosticMutationObserver } from "../core/observers.js";
+import "../icon.js";
+const style = css`@charset "UTF-8";
+/**
+ * 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-form-field-background-color: var(--sbb-color-white);
+  --sbb-form-field-border-color: var(--sbb-color-smoke);
+  --sbb-form-field-border-style: solid;
+  --sbb-form-field-border-radius: var(--sbb-border-radius-4x);
+  --sbb-form-field-border-width: var(--sbb-border-width-1x);
+  --sbb-form-field-min-height: var(--sbb-size-element-m);
+  --sbb-form-field-label-color: var(--sbb-color-metal);
+  --sbb-form-field-prefix-color: var(--sbb-color-metal);
+  --sbb-form-field-padding-inline: var(--sbb-spacing-fixed-3x);
+  --sbb-form-field-text-color: var(--sbb-color-charcoal);
+  --sbb-form-field-arrow-color: var(--sbb-color-charcoal);
+  --sbb-form-field-error-divider-width: var(--sbb-spacing-fixed-1x);
+  --sbb-form-field-error-padding-block-start: var(--sbb-form-field-error-divider-width);
+  --sbb-form-field-gap: var(--sbb-spacing-fixed-2x);
+  --sbb-form-field-label-to-input-overlapping: var(--sbb-spacing-fixed-1x);
+  --sbb-form-field-select-inline-padding-end: calc(
+    var(--sbb-icon-svg-width) + var(--sbb-form-field-gap)
+  );
+  --sbb-form-field-overflow: hidden;
+  --sbb-form-field-label-size: calc(
+    var(--sbb-font-size-text-xs) * var(--sbb-typo-line-height-body-text)
+  );
+  --sbb-form-field-input-size: calc(
+    var(--sbb-font-size-text-m) * var(--sbb-typo-line-height-body-text)
+  );
+  --sbb-form-field-margin-block-start: calc(
+    (
+        var(--sbb-form-field-min-height) - var(--sbb-form-field-label-size) - var(
+            --sbb-form-field-input-size
+          ) + var(--sbb-form-field-label-to-input-overlapping)
+      ) / 2
+  );
+  --sbb-icon-svg-width: var(--sbb-size-icon-ui-small);
+  --sbb-icon-svg-height: var(--sbb-size-icon-ui-small);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-default);
+  display: inline-block;
+}
+@media (forced-colors: active) {
+  :host {
+    --sbb-form-field-border-color: ButtonBorder;
+  }
+}
+
+:host(:where(:not([width=collapse]))) {
+  min-width: 9.375rem;
+  width: min(18.75rem, 100%);
+}
+
+:host([negative]) {
+  --sbb-form-field-background-color: var(--sbb-color-midnight);
+  --sbb-form-field-border-color: var(--sbb-color-smoke);
+  --sbb-form-field-label-color: var(--sbb-color-smoke);
+  --sbb-form-field-prefix-color: var(--sbb-color-smoke);
+  --sbb-form-field-text-color: var(--sbb-color-milk);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+  --sbb-form-field-arrow-color: var(--sbb-color-milk);
+}
+@media (forced-colors: active) {
+  :host([negative]) {
+    --sbb-form-field-border-color: ButtonBorder;
+  }
+}
+
+:host([size=l]) {
+  --sbb-form-field-min-height: var(--sbb-size-element-l);
+  --sbb-form-field-padding-inline: var(--sbb-spacing-responsive-xxxs);
+}
+
+:host([error-space=reserve]) {
+  --sbb-form-field-error-min-height: calc(
+    var(--sbb-typo-line-height-body-text) * var(--sbb-font-size-text-xs)
+  );
+  --sbb-form-field-error-padding-block-start-override: var(--sbb-form-field-error-divider-width);
+}
+
+:host(:is([data-readonly], [data-disabled])) {
+  --sbb-form-field-background-color: var(--sbb-color-milk);
+  --sbb-form-field-border-color: var(--sbb-color-graphite);
+  --sbb-form-field-arrow-color: var(--sbb-color-granite);
+}
+@media (forced-colors: active) {
+  :host(:is([data-readonly], [data-disabled])) {
+    --sbb-form-field-border-color: ButtonBorder;
+  }
+}
+
+:host(:is([data-readonly], [data-disabled])[negative]) {
+  --sbb-form-field-background-color: var(--sbb-color-charcoal);
+  --sbb-form-field-border-color: var(--sbb-color-smoke);
+  --sbb-form-field-arrow-color: var(--sbb-color-smoke);
+}
+
+:host([data-disabled]) {
+  --sbb-form-field-label-color: var(--sbb-color-granite);
+  --sbb-form-field-prefix-color: var(--sbb-color-granite);
+  --sbb-form-field-border-style: dashed;
+}
+@media (forced-colors: active) {
+  :host([data-disabled]) {
+    --sbb-form-field-label-color: GrayText !important;
+    --sbb-form-field-prefix-color: GrayText !important;
+    --sbb-form-field-text-color: GrayText !important;
+    --sbb-form-field-border-color: GrayText !important;
+  }
+}
+
+:host([data-disabled][negative]) {
+  --sbb-form-field-text-color: var(--sbb-color-smoke);
+  --sbb-form-field-label-color: var(--sbb-color-smoke);
+  --sbb-form-field-prefix-color: var(--sbb-color-smoke);
+}
+
+:host([data-readonly]:not([negative])) {
+  --sbb-form-field-label-color: var(--sbb-color-granite);
+  --sbb-form-field-prefix-color: var(--sbb-color-granite);
+}
+
+:host(:is([data-input-focused], [data-has-popup-open])) {
+  --sbb-form-field-border-color: var(--sbb-color-charcoal);
+  --sbb-form-field-prefix-color: var(--sbb-color-charcoal);
+  --sbb-form-field-border-width: var(--sbb-border-width-2x);
+}
+@media (forced-colors: active) {
+  :host(:is([data-input-focused], [data-has-popup-open])) {
+    --sbb-form-field-border-color: Highlight !important;
+    --sbb-form-field-prefix-color: Highlight !important;
+  }
+}
+
+:host(:is([data-input-focused], [data-has-popup-open])[negative]) {
+  --sbb-form-field-border-color: var(--sbb-color-milk);
+  --sbb-form-field-prefix-color: var(--sbb-color-milk);
+}
+
+:host([data-invalid]) {
+  --sbb-form-field-border-color: var(--sbb-color-red125);
+  --sbb-form-field-text-color: var(--sbb-color-red125);
+}
+@media (forced-colors: active) {
+  :host([data-invalid]) {
+    --sbb-form-field-border-color: LinkText !important;
+    --sbb-form-field-text-color: LinkText !important;
+  }
+}
+
+:host([data-invalid][negative]) {
+  --sbb-form-field-border-color: var(--sbb-color-red-mode-dark);
+  --sbb-form-field-text-color: var(--sbb-color-red-mode-dark);
+}
+
+:host(:not([data-has-error])) {
+  --sbb-form-field-error-padding-block-start: 0;
+}
+
+:host([floating-label]) {
+  --sbb-select-placeholder-color: transparent;
+}
+@media (forced-colors: active) {
+  :host([floating-label]) {
+    --sbb-select-placeholder-color: Canvas;
+  }
+}
+
+:host(:is(:not([data-slot-names~=label], [label]), [hidden-label])) {
+  --sbb-form-field-label-size: 0rem;
+  --sbb-form-field-label-to-input-overlapping: 0rem;
+}
+
+:host([data-input-type=sbb-slider]) {
+  --sbb-form-field-overflow: visible;
+}
+
+:host([data-input-type=textarea]) {
+  --sbb-form-field-max-height: fit-content;
+}
+
+.sbb-form-field__space-wrapper {
+  display: flex;
+  flex-direction: column;
+}
+.sbb-form-field__space-wrapper::before {
+  content: "​";
+  user-select: none;
+  width: 0;
+  height: 0;
+}
+
+.sbb-form-field__wrapper {
+  display: flex;
+  gap: var(--sbb-form-field-gap);
+  padding-inline: var(--sbb-form-field-padding-inline);
+  border-radius: var(--sbb-form-field-border-radius);
+  min-height: var(--sbb-form-field-min-height);
+  max-height: var(--sbb-form-field-max-height);
+  background-color: var(--sbb-form-field-background-color);
+  position: relative;
+}
+.sbb-form-field__wrapper::before {
+  content: "";
+  display: block;
+  position: absolute;
+  inset: 0;
+  border: var(--sbb-form-field-border-width) var(--sbb-form-field-border-style) var(--sbb-form-field-border-color);
+  border-radius: var(--sbb-form-field-border-radius);
+}
+:host([data-input-focused][data-focus-origin=keyboard]) .sbb-form-field__wrapper {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) solid var(--sbb-focus-outline-width);
+}
+@media (forced-colors: none) {
+  :host(:is([borderless], [data-input-type=sbb-slider])) .sbb-form-field__wrapper::before {
+    border-color: transparent;
+  }
+  :host(:is([data-input-focused], [data-has-popup-open])[borderless]) .sbb-form-field__wrapper::after {
+    content: "";
+    position: absolute;
+    border-block-end: var(--sbb-border-width-1x) var(--sbb-form-field-border-style) var(--sbb-form-field-border-color);
+    inset-inline: var(--sbb-form-field-padding-inline);
+    inset-block-end: 0;
+  }
+}
+
+::slotted(*[slot=prefix]) {
+  color: var(--sbb-form-field-prefix-color);
+}
+
+::slotted(*[slot=prefix]),
+::slotted(*[slot=suffix]) {
+  display: flex;
+  min-width: var(--sbb-icon-svg-width);
+  margin-block-start: calc((var(--sbb-form-field-min-height) - var(--sbb-size-icon-ui-small)) / 2);
+}
+
+:host(:is([data-input-empty], [data-disabled], [data-readonly])) ::slotted(sbb-form-field-clear) {
+  display: none;
+}
+
+::slotted(sbb-datepicker-toggle) {
+  height: calc((var(--sbb-form-field-min-height) + var(--sbb-size-icon-ui-small)) / 2);
+}
+
+@media (forced-colors: active) {
+  ::slotted(*[slot=suffix]) {
+    color: var(--sbb-form-field-prefix-color);
+  }
+}
+.sbb-form-field__select-input-icon {
+  position: absolute;
+  top: 50%;
+  transform: translateY(-50%);
+  position: absolute;
+  inset-inline-end: 0;
+  margin-block-start: calc(-1 * var(--sbb-form-field-margin-block-start) / 2);
+  pointer-events: none;
+  color: var(--sbb-form-field-arrow-color);
+}
+
+.sbb-form-field__input-container {
+  flex: 1 1 auto;
+  position: relative;
+  margin-block-start: var(--sbb-form-field-margin-block-start);
+  min-width: 0;
+}
+
+.sbb-form-field__label-spacer {
+  display: flex;
+  height: calc(var(--sbb-font-size-text-xs) * var(--sbb-typo-line-height-body-text));
+  margin-block-end: calc(-1 * var(--sbb-form-field-label-to-input-overlapping));
+}
+
+:host(:not([data-slot-names~=label], [label])) :is(.sbb-form-field__label, .sbb-form-field__label-spacer) {
+  display: none;
+}
+:host([hidden-label]) :is(.sbb-form-field__label, .sbb-form-field__label-spacer) {
+  border: 0;
+  clip: rect(0 0 0 0);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+  width: 1px;
+}
+
+.sbb-form-field__label {
+  --sbb-text-font-size: var(--sbb-font-size-text-xs);
+  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: flex;
+  max-width: 100%;
+  cursor: default;
+  position: absolute;
+  inset-block-start: 0;
+  color: var(--sbb-form-field-label-color);
+}
+:host([data-input-type=select]) .sbb-form-field__label, :host([data-input-type=sbb-select]) .sbb-form-field__label {
+  padding-inline-end: var(--sbb-form-field-select-inline-padding-end);
+}
+:host([floating-label]) .sbb-form-field__label {
+  transform-origin: 0 0;
+  pointer-events: none;
+  backface-visibility: hidden;
+  will-change: transform, font-size;
+  transition-duration: var(--sbb-disable-animation-zero-time, var(--sbb-animation-duration-2x));
+  transition-timing-function: var(--sbb-animation-easing);
+  transition-property: transform, font-size;
+}
+:host([floating-label]:is(:not([data-input-focused]:not([data-input-type=sbb-select]), [data-has-popup-open]),
+[data-readonly])[data-input-empty]) .sbb-form-field__label {
+  font-size: var(--sbb-font-size-text-m);
+  transform: translateY(0.53125rem);
+}
+@media (min-width: calc(52.5rem)) {
+  :host([floating-label]:is(:not([data-input-focused]:not([data-input-type=sbb-select]), [data-has-popup-open]),
+  [data-readonly])[data-input-empty]) .sbb-form-field__label {
+    transform: translateY(0.65625rem);
+  }
+}
+
+.sbb-form-field__label-ellipsis {
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.sbb-form-field__input ::slotted(:where(input, select, textarea, sbb-select)) {
+  --sbb-text-font-size: var(--sbb-font-size-text-m);
+  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);
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  outline: none;
+  border: none;
+  background-color: transparent;
+  padding: 0;
+  -webkit-appearance: none;
+  outline: none !important;
+  overflow: var(--sbb-form-field-overflow);
+  width: 100%;
+  box-sizing: border-box;
+  color: var(--sbb-form-field-text-color);
+  -webkit-text-fill-color: var(--sbb-form-field-text-color);
+  opacity: 1;
+  background-color: transparent;
+  font-size: var(--sbb-font-size-text-m) !important;
+  font-family: var(--sbb-typo-font-family) !important;
+  line-height: var(--sbb-typo-line-height-body-text) !important;
+}
+.sbb-form-field__input ::slotted(:where(input, select, textarea, sbb-select))::placeholder {
+  color: var(--sbb-color-metal);
+  -webkit-text-fill-color: var(--sbb-color-metal);
+  opacity: 1;
+}
+:host([floating-label]) .sbb-form-field__input ::slotted(:where(input, select, textarea, sbb-select))::placeholder {
+  color: transparent !important;
+  -webkit-text-fill-color: transparent !important;
+}
+@media (forced-colors: active) {
+  :host([floating-label]) .sbb-form-field__input ::slotted(:where(input, select, textarea, sbb-select))::placeholder {
+    color: Canvas !important;
+    -webkit-text-fill-color: Canvas !important;
+  }
+}
+:host([data-disabled]:not([floating-label])) .sbb-form-field__input ::slotted(:where(input, select, textarea, sbb-select))::placeholder {
+  color: var(--sbb-color-granite);
+  -webkit-text-fill-color: var(--sbb-color-granite);
+}
+:host([data-input-type=select]) .sbb-form-field__input ::slotted(:where(input, select, textarea, sbb-select)) {
+  vertical-align: middle;
+}
+
+.sbb-form-field__input ::slotted(:where(select, sbb-select)) {
+  padding-inline-end: var(--sbb-form-field-select-inline-padding-end);
+}
+
+.sbb-form-field__input ::slotted(textarea) {
+  --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-scrollbar-width: var(--sbb-spacing-fixed-3x);
+  /* Scrollbar itself */
+  /* Hide button (top and bottom of the scrollbar) */
+  position: relative;
+  resize: none;
+  white-space: break-spaces;
+  overflow-y: auto;
+  min-height: calc(var(--sbb-typo-line-height-body-text) * 1em);
+}
+.sbb-form-field__input ::slotted(textarea)::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-form-field__input ::slotted(textarea)::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-form-field__input ::slotted(textarea)::-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-form-field__input ::slotted(textarea)::-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-form-field__input ::slotted(textarea)::-webkit-scrollbar-button, .sbb-form-field__input ::slotted(textarea)::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-form-field__input ::slotted(textarea) {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+:host([negative]) .sbb-form-field__input ::slotted(textarea) {
+  --sbb-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: var(--sbb-color-white-alpha-30);
+  --sbb-scrollbar-color-hover: var(--sbb-color-white-alpha-60);
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+  /* Scrollbar itself */
+  /* Hide button (top and bottom of the scrollbar) */
+}
+:host([negative]) .sbb-form-field__input ::slotted(textarea)::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+:host([negative]) .sbb-form-field__input ::slotted(textarea)::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+:host([negative]) .sbb-form-field__input ::slotted(textarea)::-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;
+}
+:host([negative]) .sbb-form-field__input ::slotted(textarea)::-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)));
+}
+:host([negative]) .sbb-form-field__input ::slotted(textarea)::-webkit-scrollbar-button, :host([negative]) .sbb-form-field__input ::slotted(textarea)::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  :host([negative]) .sbb-form-field__input ::slotted(textarea) {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+
+.sbb-form-field__error {
+  display: flex;
+  min-height: var(--sbb-form-field-error-min-height);
+  margin-block-start: var(--sbb-form-field-error-padding-block-start-override, var(--sbb-form-field-error-padding-block-start));
+}`;
+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 nextId = 0;
+let nextFormFieldErrorId = 0;
+const supportedPopupTagNames = ["sbb-autocomplete", "sbb-select"];
+let SbbFormFieldElement = class extends SbbNegativeMixin(LitElement) {
+  constructor() {
+    super();
+    this._supportedNativeInputElements = ["input", "select", "textarea"];
+    this._supportedInputElements = [
+      ...this._supportedNativeInputElements,
+      "sbb-select",
+      "sbb-slider"
+    ];
+    this._excludedFocusElements = ["button", "sbb-popover"];
+    this._floatingLabelSupportedInputElements = [
+      "input",
+      "select",
+      "sbb-select",
+      "textarea"
+    ];
+    this._floatingLabelSupportedInputTypes = [
+      "email",
+      "number",
+      "password",
+      "search",
+      "tel",
+      "text",
+      "url"
+    ];
+    this.errorSpace = "none";
+    this.size = "m";
+    this.borderless = false;
+    this.width = "default";
+    this.hiddenLabel = false;
+    this.floatingLabel = false;
+    this._errorElements = [];
+    this._abort = new SbbConnectedAbortController(this);
+    this._language = new SbbLanguageController(this);
+    this._formFieldAttributeObserver = new AgnosticMutationObserver(
+      (mutations) => {
+        if (mutations.some((m) => m.type === "attributes")) {
+          this._readInputState();
+        }
+      }
+    );
+    this._inputAbortController = new AbortController();
+    new SbbSlotStateController(this);
+  }
+  /** Returns the input element. */
+  get inputElement() {
+    return this._input;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const signal = this._abort.signal;
+    this.addEventListener("willOpen", (e) => this._onPopupOpen(e), { signal });
+    this.addEventListener("didClose", (e) => this._onPopupClose(e), { signal });
+    this._registerInputListener();
+    this._syncNegative();
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("negative")) {
+      this._syncNegative();
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._formFieldAttributeObserver.disconnect();
+    this._inputAbortController.abort();
+  }
+  _onPopupOpen({ target }) {
+    if (supportedPopupTagNames.includes(target.localName)) {
+      this.toggleAttribute("data-has-popup-open", true);
+    }
+  }
+  _onPopupClose({ target }) {
+    if (supportedPopupTagNames.includes(target.localName)) {
+      this.removeAttribute("data-has-popup-open");
+    }
+  }
+  _handleWrapperClick(event) {
+    var _a, _b;
+    if (this._isButtonOrPopup(event)) {
+      return;
+    }
+    if (((_a = this._input) == null ? void 0 : _a.localName) === "sbb-select") {
+      this._input.click();
+      this._input.focus();
+    } else if (event.target.localName !== "label") {
+      (_b = this._input) == null ? void 0 : _b.focus();
+    }
+  }
+  _isButtonOrPopup(event) {
+    return event.composedPath().some(
+      (el) => el instanceof window.HTMLElement && el.getAttribute("role") === "button" || this._excludedFocusElements.includes(el.localName)
+    );
+  }
+  _onSlotLabelChange() {
+    const labels = Array.from(this.querySelectorAll("label"));
+    if (labels.length > 1) {
+      console.warn(
+        `Detected more than one label in sbb-form-field#${this.id}. Only one label is supported.`
+      );
+    }
+    this._label = labels[0];
+    this._syncLabelInputReferences();
+  }
+  /**
+   * It is used internally to assign the attributes of `<input>` to `_id` and `_input` and to observe the native readonly and disabled attributes.
+   */
+  _onSlotInputChange(event) {
+    this._input = event.target.assignedElements().find((e) => this._supportedInputElements.includes(e.localName));
+    this._assignSlots();
+    if (!this._input) {
+      return;
+    }
+    this._originalInputAriaDescribedby = this._input.getAttribute("aria-describedby");
+    this._applyAriaDescribedby();
+    this._readInputState();
+    this._registerInputListener();
+    if (this._input.localName === "textarea") {
+      this._input.setAttribute("rows", this._input.getAttribute("rows") || "3");
+    }
+    this._formFieldAttributeObserver.disconnect();
+    this._formFieldAttributeObserver.observe(this._input, {
+      attributes: true,
+      attributeFilter: ["readonly", "disabled", "class", "data-sbb-invalid"]
+    });
+    this.setAttribute("data-input-type", this._input.localName);
+    this._syncLabelInputReferences();
+  }
+  _syncLabelInputReferences() {
+    var _a;
+    if (!this._input || !this._label) {
+      return;
+    }
+    if (this._supportedNativeInputElements.includes(this._input.localName)) {
+      if (!this._input.id) {
+        this._input.id = `sbb-form-field-input-${nextId++}`;
+      }
+      this._label.htmlFor = this._input.id;
+    } else {
+      if (!this._label.id) {
+        this._label.id = `sbb-form-field-label-${nextId++}`;
+      }
+      const labelledby = ((_a = this._input.getAttribute("aria-labelledby")) == null ? void 0 : _a.split(" ").filter((l) => !!l && l !== this._label.id)) ?? [];
+      this._input.setAttribute("aria-labelledby", [...labelledby, this._label.id].join(" "));
+    }
+  }
+  _registerInputListener() {
+    var _a;
+    if (!this._input) {
+      return;
+    }
+    this._inputAbortController.abort();
+    this._inputAbortController = new AbortController();
+    this._checkAndUpdateInputEmpty();
+    (_a = this._getInputForm()) == null ? void 0 : _a.addEventListener("reset", () => setTimeout(() => this.reset()), {
+      signal: this._inputAbortController.signal
+    });
+    this._input.addEventListener("input", () => this._checkAndUpdateInputEmpty(), {
+      signal: this._inputAbortController.signal
+    });
+    this._input.addEventListener("blur", () => this._checkAndUpdateInputEmpty(), {
+      signal: this._inputAbortController.signal
+    });
+    let inputFocusElement = this._input;
+    if (this._input.localName === "sbb-select") {
+      this._input.addEventListener("stateChange", () => this._checkAndUpdateInputEmpty(), {
+        signal: this._inputAbortController.signal
+      });
+      inputFocusElement = this._input.inputElement;
+    }
+    inputFocusElement.addEventListener(
+      "focusin",
+      () => {
+        this.toggleAttribute("data-input-focused", true);
+        this.setAttribute(
+          "data-focus-origin",
+          sbbInputModalityDetector.mostRecentModality ?? ""
+        );
+      },
+      {
+        signal: this._inputAbortController.signal
+      }
+    );
+    inputFocusElement.addEventListener(
+      "focusout",
+      () => ["data-focus-origin", "data-input-focused"].forEach((name) => this.removeAttribute(name)),
+      {
+        signal: this._inputAbortController.signal
+      }
+    );
+  }
+  _getInputForm() {
+    var _a;
+    if (this._input instanceof HTMLInputElement || this._input instanceof HTMLSelectElement) {
+      return this._input.form;
+    }
+    return (_a = this._input) == null ? void 0 : _a.closest("form");
+  }
+  _checkAndUpdateInputEmpty() {
+    var _a;
+    this.toggleAttribute(
+      "data-input-empty",
+      this._floatingLabelSupportedInputElements.includes((_a = this._input) == null ? void 0 : _a.localName) && this._isInputEmpty()
+    );
+  }
+  _isInputEmpty() {
+    var _a, _b, _c, _d, _e;
+    if (this._input instanceof HTMLInputElement) {
+      return this._floatingLabelSupportedInputTypes.includes(this._input.type) && this._isInputValueEmpty();
+    } else if (this._input instanceof HTMLSelectElement) {
+      return ((_c = (_b = (_a = this._input.selectedOptions) == null ? void 0 : _a.item(0)) == null ? void 0 : _b.label) == null ? void 0 : _c.trim()) === "";
+    } else if (((_d = this._input) == null ? void 0 : _d.localName) === "sbb-select") {
+      return ((_e = this._input.getDisplayValue()) == null ? void 0 : _e.trim()) === "";
+    } else {
+      return this._isInputValueEmpty();
+    }
+  }
+  _isInputValueEmpty() {
+    const value = this._input.value;
+    return ["", void 0, null].includes(value) || Array.isArray(value) && value.length === 0;
+  }
+  _assignSlots() {
+    this.querySelectorAll("label:not([slot])").forEach((e) => e.setAttribute("slot", "label"));
+    this.querySelectorAll("sbb-form-error:not([slot])").forEach(
+      (e) => e.setAttribute("slot", "error")
+    );
+  }
+  _readInputState() {
+    if (!this._input) {
+      return;
+    }
+    this.toggleAttribute("data-readonly", this._input.hasAttribute("readonly"));
+    this.toggleAttribute("data-disabled", this._input.hasAttribute("disabled"));
+    this.toggleAttribute(
+      "data-invalid",
+      this._input.hasAttribute("data-sbb-invalid") || this._input.classList.contains("sbb-invalid") || this._input.classList.contains("ng-touched") && this._input.classList.contains("ng-invalid")
+    );
+  }
+  /**
+   * It is used internally to set the aria-describedby attribute for the slotted input referencing available <sbb-form-error> instances.
+   */
+  _onSlotErrorChange(event) {
+    this._errorElements = event.target.assignedElements();
+    for (const el of this._errorElements) {
+      if (!el.id) {
+        el.id = `sbb-form-field-error-${++nextFormFieldErrorId}`;
+      }
+      if (!el.role) {
+        el.role = "status";
+        if (isFirefox) {
+          el.setAttribute("role", "status");
+        }
+      }
+    }
+    this._applyAriaDescribedby();
+    this.toggleAttribute("data-has-error", !!this._errorElements.length);
+    this._syncNegative();
+  }
+  _applyAriaDescribedby() {
+    const ids = [];
+    if (this._originalInputAriaDescribedby) {
+      ids.push(this._originalInputAriaDescribedby);
+    }
+    if (this._errorElements.length) {
+      this._errorElements.forEach((e) => ids.push(e.id));
+    }
+    const ariaDescribedby = ids.join(" ");
+    if (this._input) {
+      setOrRemoveAttribute(this._input, "aria-describedby", ariaDescribedby);
+    }
+  }
+  /** Manually reset the form field. Currently, this only resets the floating label. */
+  reset() {
+    this._checkAndUpdateInputEmpty();
+  }
+  /** Manually clears the input value. It only works for inputs, selects are not supported. */
+  clear() {
+    var _a;
+    if (((_a = this._input) == null ? void 0 : _a.localName) !== "input") {
+      return;
+    }
+    this._input.value = "";
+    this._checkAndUpdateInputEmpty();
+  }
+  /**
+   * Returns the input element.
+   * @deprecated Use the 'inputElement' property instead
+   */
+  getInputElement() {
+    return this._input;
+  }
+  _syncNegative() {
+    var _a;
+    (_a = this.querySelectorAll) == null ? void 0 : _a.call(
+      this,
+      "sbb-form-error,sbb-mini-button,sbb-popover-trigger,sbb-form-field-clear,sbb-datepicker-next-day,sbb-datepicker-previous-day,sbb-datepicker-toggle,sbb-select,sbb-autocomplete"
+    ).forEach((element) => element.toggleAttribute("negative", this.negative));
+  }
+  render() {
+    var _a;
+    return html`
+      <div class="sbb-form-field__space-wrapper">
+        ${/* Queried by id from the autocomplete/select to be used as the anchor element */
+    ""}
+        <div @click=${this._handleWrapperClick} class="sbb-form-field__wrapper" id="overlay-anchor">
+          <slot name="prefix" @slotchange=${this._syncNegative}></slot>
+          <div class="sbb-form-field__input-container">
+            <span class="sbb-form-field__label-spacer" aria-hidden="true"></span>
+            <span class="sbb-form-field__label">
+              <span class="sbb-form-field__label-ellipsis">
+                <slot name="label" @slotchange=${this._onSlotLabelChange}></slot>
+                ${this.optional ? html` <span aria-hidden="true"> ${i18nOptional[this._language.current]} </span>` : nothing}
+              </span>
+            </span>
+            <div class="sbb-form-field__input">
+              <slot @slotchange=${this._onSlotInputChange}></slot>
+            </div>
+            ${["select", "sbb-select"].includes((_a = this._input) == null ? void 0 : _a.localName) ? html`<sbb-icon
+                  name="chevron-small-down-small"
+                  class="sbb-form-field__select-input-icon"
+                ></sbb-icon>` : nothing}
+          </div>
+          <slot name="suffix" @slotchange=${this._syncNegative}></slot>
+        </div>
+
+        <div class="sbb-form-field__error">
+          <slot name="error" @slotchange=${this._onSlotErrorChange}></slot>
+        </div>
+      </div>
+    `;
+  }
+};
+SbbFormFieldElement.styles = style;
+__decorateClass([
+  property({ attribute: "error-space", reflect: true })
+], SbbFormFieldElement.prototype, "errorSpace", 2);
+__decorateClass([
+  property({ type: Boolean })
+], SbbFormFieldElement.prototype, "optional", 2);
+__decorateClass([
+  property({ reflect: true })
+], SbbFormFieldElement.prototype, "size", 2);
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbFormFieldElement.prototype, "borderless", 2);
+__decorateClass([
+  property({ reflect: true })
+], SbbFormFieldElement.prototype, "width", 2);
+__decorateClass([
+  property({ attribute: "hidden-label", reflect: true, type: Boolean })
+], SbbFormFieldElement.prototype, "hiddenLabel", 2);
+__decorateClass([
+  property({ attribute: "floating-label", reflect: true, type: Boolean })
+], SbbFormFieldElement.prototype, "floatingLabel", 2);
+__decorateClass([
+  state()
+], SbbFormFieldElement.prototype, "_errorElements", 2);
+__decorateClass([
+  state()
+], SbbFormFieldElement.prototype, "_input", 2);
+__decorateClass([
+  state()
+], SbbFormFieldElement.prototype, "_label", 2);
+SbbFormFieldElement = __decorateClass([
+  customElement("sbb-form-field")
+], SbbFormFieldElement);
+export {
+  SbbFormFieldElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-field.js","sources":["../../../../src/elements/form-field/form-field/form-field.ts"],"sourcesContent":["import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, LitElement, nothing } from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\n\nimport type { SbbInputModality } from '../../core/a11y.js';\nimport { sbbInputModalityDetector } from '../../core/a11y.js';\nimport {\n  SbbConnectedAbortController,\n  SbbLanguageController,\n  SbbSlotStateController,\n} from '../../core/controllers.js';\nimport { isFirefox, setOrRemoveAttribute } from '../../core/dom.js';\nimport { i18nOptional } from '../../core/i18n.js';\nimport { SbbNegativeMixin } from '../../core/mixins.js';\nimport { AgnosticMutationObserver } from '../../core/observers.js';\nimport type { SbbSelectElement } from '../../select.js';\nimport '../../icon.js';\n\nimport style from './form-field.scss?lit&inline';\n\nlet nextId = 0;\nlet nextFormFieldErrorId = 0;\n\nconst supportedPopupTagNames = ['sbb-autocomplete', 'sbb-select'];\n\n/**\n * It wraps an input element adding label, errors, icon, etc.\n *\n * @slot - Use this slot to render an input/select or a supported non-native element.\n * @slot label - Use this slot to render a label.\n * @slot prefix - Use this slot to render an icon on the left side of the input.\n * @slot suffix - Use this slot to render an icon on the right side of the input.\n * @slot error - Use this slot to render an error.\n */\n@customElement('sbb-form-field')\nexport class SbbFormFieldElement extends SbbNegativeMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n\n  private readonly _supportedNativeInputElements = ['input', 'select', 'textarea'];\n  // List of supported element selectors in unnamed slot\n  private readonly _supportedInputElements = [\n    ...this._supportedNativeInputElements,\n    'sbb-select',\n    'sbb-slider',\n  ];\n  // List of elements that should not focus input on click\n  private readonly _excludedFocusElements = ['button', 'sbb-popover'];\n\n  private readonly _floatingLabelSupportedInputElements = [\n    'input',\n    'select',\n    'sbb-select',\n    'textarea',\n  ];\n\n  private readonly _floatingLabelSupportedInputTypes = [\n    'email',\n    'number',\n    'password',\n    'search',\n    'tel',\n    'text',\n    'url',\n  ];\n\n  /**\n   * Whether to reserve space for an error message.\n   * `none` does not reserve any space.\n   * `reserve` does reserve one row for an error message.\n   */\n  @property({ attribute: 'error-space', reflect: true })\n  public errorSpace?: 'none' | 'reserve' = 'none';\n\n  /** Indicates whether the input is optional. */\n  @property({ type: Boolean }) public optional?: boolean;\n\n  /** Size variant, either l or m. */\n  @property({ reflect: true }) public size?: 'l' | 'm' = 'm';\n\n  /** Whether to display the form field without a border. */\n  @property({ reflect: true, type: Boolean }) public borderless = false;\n\n  /** Defines the width of the component:\n   * - `default`: the component has defined width and min-width;\n   * - `collapse`: the component adapts itself to its inner input content. */\n  @property({ reflect: true }) public width: 'default' | 'collapse' = 'default';\n\n  /** Whether to visually hide the label. If hidden, screen readers will still read it. */\n  @property({ attribute: 'hidden-label', reflect: true, type: Boolean }) public hiddenLabel = false;\n\n  /** Whether the label should float. If activated, the placeholder of the input is hidden. */\n  @property({ attribute: 'floating-label', reflect: true, type: Boolean }) public floatingLabel =\n    false;\n\n  /** It is used internally to get the `error` slot. */\n  @state() private _errorElements: Element[] = [];\n\n  /** Original aria-describedby value of the slotted input element. */\n  private _originalInputAriaDescribedby?: string | null;\n\n  /** Reference to the slotted input element. */\n  @state() private _input?: HTMLInputElement | HTMLSelectElement | HTMLElement;\n\n  /** Reference to the slotted label elements. */\n  @state() private _label?: HTMLLabelElement;\n\n  /** Returns the input element. */\n  public get inputElement(): HTMLInputElement | HTMLSelectElement | HTMLElement | undefined {\n    return this._input;\n  }\n\n  private _abort = new SbbConnectedAbortController(this);\n  private _language = new SbbLanguageController(this);\n\n  /**\n   * Listens to the changes on `readonly` and `disabled` attributes of `<input>`.\n   */\n  private _formFieldAttributeObserver = new AgnosticMutationObserver(\n    (mutations: MutationRecord[]) => {\n      if (mutations.some((m) => m.type === 'attributes')) {\n        this._readInputState();\n      }\n    },\n  );\n\n  private _inputAbortController = new AbortController();\n\n  public constructor() {\n    super();\n    new SbbSlotStateController(this);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    const signal = this._abort.signal;\n    this.addEventListener('willOpen', (e: CustomEvent<void>) => this._onPopupOpen(e), { signal });\n    this.addEventListener('didClose', (e: CustomEvent<void>) => this._onPopupClose(e), { signal });\n    this._registerInputListener();\n    this._syncNegative();\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('negative')) {\n      this._syncNegative();\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._formFieldAttributeObserver.disconnect();\n    this._inputAbortController.abort();\n  }\n\n  private _onPopupOpen({ target }: CustomEvent<void>): void {\n    if (supportedPopupTagNames.includes((target as HTMLElement).localName)) {\n      this.toggleAttribute('data-has-popup-open', true);\n    }\n  }\n\n  private _onPopupClose({ target }: CustomEvent<void>): void {\n    if (supportedPopupTagNames.includes((target as HTMLElement).localName)) {\n      this.removeAttribute('data-has-popup-open');\n    }\n  }\n\n  private _handleWrapperClick(event: Event): void {\n    if (this._isButtonOrPopup(event)) {\n      return;\n    }\n\n    if (this._input?.localName === 'sbb-select') {\n      this._input.click();\n      this._input.focus();\n    } else if ((event.target as Element).localName !== 'label') {\n      this._input?.focus();\n    }\n  }\n\n  private _isButtonOrPopup(event: Event): boolean {\n    return event\n      .composedPath()\n      .some(\n        (el) =>\n          (el instanceof window.HTMLElement && el.getAttribute('role') === 'button') ||\n          this._excludedFocusElements.includes((el as HTMLElement).localName),\n      );\n  }\n\n  private _onSlotLabelChange(): void {\n    const labels = Array.from(this.querySelectorAll('label'));\n    if (import.meta.env.DEV && labels.length > 1) {\n      console.warn(\n        `Detected more than one label in sbb-form-field#${this.id}. Only one label is supported.`,\n      );\n    }\n    this._label = labels[0];\n    this._syncLabelInputReferences();\n  }\n\n  /**\n   * It is used internally to assign the attributes of `<input>` to `_id` and `_input` and to observe the native readonly and disabled attributes.\n   */\n  private _onSlotInputChange(event: Event): void {\n    this._input = (event.target as HTMLSlotElement)\n      .assignedElements()\n      .find((e): e is HTMLElement => this._supportedInputElements.includes(e.localName));\n    this._assignSlots();\n\n    if (!this._input) {\n      return;\n    }\n\n    this._originalInputAriaDescribedby = this._input.getAttribute('aria-describedby');\n    this._applyAriaDescribedby();\n    this._readInputState();\n    this._registerInputListener();\n\n    if (this._input.localName === 'textarea') {\n      this._input.setAttribute('rows', this._input.getAttribute('rows') || '3');\n    }\n\n    this._formFieldAttributeObserver.disconnect();\n    this._formFieldAttributeObserver.observe(this._input, {\n      attributes: true,\n      attributeFilter: ['readonly', 'disabled', 'class', 'data-sbb-invalid'],\n    });\n    this.setAttribute('data-input-type', this._input.localName);\n    this._syncLabelInputReferences();\n  }\n\n  private _syncLabelInputReferences(): void {\n    if (!this._input || !this._label) {\n      return;\n    }\n\n    if (this._supportedNativeInputElements.includes(this._input.localName)) {\n      // For native input elements we use the `for` attribute on the label to reference the input\n      // via id reference.\n      if (!this._input.id) {\n        this._input.id = `sbb-form-field-input-${nextId++}`;\n      }\n\n      this._label.htmlFor = this._input.id;\n    } else {\n      // For non-native input elements, that do not support references via the label for attribute,\n      // we use aria-labelledby on the input element to reference the label element via id.\n      if (!this._label.id) {\n        this._label.id = `sbb-form-field-label-${nextId++}`;\n      }\n      const labelledby =\n        this._input\n          .getAttribute('aria-labelledby')\n          ?.split(' ')\n          .filter((l) => !!l && l !== this._label!.id) ?? [];\n      this._input.setAttribute('aria-labelledby', [...labelledby, this._label.id].join(' '));\n    }\n  }\n\n  private _registerInputListener(): void {\n    if (!this._input) {\n      return;\n    }\n    this._inputAbortController.abort();\n    this._inputAbortController = new AbortController();\n    this._checkAndUpdateInputEmpty();\n\n    // Timeout needed to have value updated\n    this._getInputForm()?.addEventListener('reset', () => setTimeout(() => this.reset()), {\n      signal: this._inputAbortController.signal,\n    });\n\n    this._input.addEventListener('input', () => this._checkAndUpdateInputEmpty(), {\n      signal: this._inputAbortController.signal,\n    });\n\n    this._input.addEventListener('blur', () => this._checkAndUpdateInputEmpty(), {\n      signal: this._inputAbortController.signal,\n    });\n\n    let inputFocusElement = this._input;\n\n    if (this._input.localName === 'sbb-select') {\n      this._input.addEventListener('stateChange', () => this._checkAndUpdateInputEmpty(), {\n        signal: this._inputAbortController.signal,\n      });\n\n      inputFocusElement = (this._input as SbbSelectElement).inputElement;\n    }\n\n    inputFocusElement.addEventListener(\n      'focusin',\n      () => {\n        this.toggleAttribute('data-input-focused', true);\n        this.setAttribute(\n          'data-focus-origin',\n          (sbbInputModalityDetector.mostRecentModality as SbbInputModality) ?? '',\n        );\n      },\n      {\n        signal: this._inputAbortController.signal,\n      },\n    );\n\n    inputFocusElement.addEventListener(\n      'focusout',\n      () =>\n        ['data-focus-origin', 'data-input-focused'].forEach((name) => this.removeAttribute(name)),\n      {\n        signal: this._inputAbortController.signal,\n      },\n    );\n  }\n\n  private _getInputForm(): HTMLFormElement | null | undefined {\n    if (this._input instanceof HTMLInputElement || this._input instanceof HTMLSelectElement) {\n      return this._input.form;\n    }\n    return this._input?.closest('form');\n  }\n\n  private _checkAndUpdateInputEmpty(): void {\n    this.toggleAttribute(\n      'data-input-empty',\n      this._floatingLabelSupportedInputElements.includes(this._input?.localName as string) &&\n        this._isInputEmpty(),\n    );\n  }\n\n  private _isInputEmpty(): boolean {\n    if (this._input instanceof HTMLInputElement) {\n      return (\n        this._floatingLabelSupportedInputTypes.includes(this._input.type) &&\n        this._isInputValueEmpty()\n      );\n    } else if (this._input instanceof HTMLSelectElement) {\n      return this._input.selectedOptions?.item(0)?.label?.trim() === '';\n    } else if (this._input?.localName === 'sbb-select') {\n      return (this._input as SbbSelectElement).getDisplayValue()?.trim() === '';\n    } else {\n      return this._isInputValueEmpty();\n    }\n  }\n\n  private _isInputValueEmpty(): boolean {\n    const value = (this._input as { value: string }).value;\n    return ['', undefined, null].includes(value) || (Array.isArray(value) && value.length === 0);\n  }\n\n  private _assignSlots(): void {\n    this.querySelectorAll('label:not([slot])').forEach((e) => e.setAttribute('slot', 'label'));\n    this.querySelectorAll('sbb-form-error:not([slot])').forEach((e) =>\n      e.setAttribute('slot', 'error'),\n    );\n  }\n\n  private _readInputState(): void {\n    if (!this._input) {\n      return;\n    }\n    this.toggleAttribute('data-readonly', this._input.hasAttribute('readonly'));\n    this.toggleAttribute('data-disabled', this._input.hasAttribute('disabled'));\n    this.toggleAttribute(\n      'data-invalid',\n      this._input.hasAttribute('data-sbb-invalid') ||\n        this._input.classList.contains('sbb-invalid') ||\n        (this._input.classList.contains('ng-touched') &&\n          this._input.classList.contains('ng-invalid')),\n    );\n  }\n\n  /**\n   * It is used internally to set the aria-describedby attribute for the slotted input referencing available <sbb-form-error> instances.\n   */\n  private _onSlotErrorChange(event: Event): void {\n    this._errorElements = (event.target as HTMLSlotElement).assignedElements();\n\n    for (const el of this._errorElements) {\n      // Although a form error assigns an id itself, we need to be earlier by creating one here\n      if (!el.id) {\n        el.id = `sbb-form-field-error-${++nextFormFieldErrorId}`;\n      }\n      if (!el.role) {\n        // Instead of defining a container with an aria-live region as expected, we had to change\n        // setting it for every slotted element to properly work in all browsers and screen reader combinations.\n        el.role = 'status';\n        if (isFirefox) {\n          el.setAttribute('role', 'status');\n        }\n      }\n    }\n    this._applyAriaDescribedby();\n    this.toggleAttribute('data-has-error', !!this._errorElements.length);\n    this._syncNegative();\n  }\n\n  private _applyAriaDescribedby(): void {\n    const ids = [];\n\n    if (this._originalInputAriaDescribedby) {\n      ids.push(this._originalInputAriaDescribedby);\n    }\n\n    if (this._errorElements.length) {\n      this._errorElements.forEach((e) => ids.push(e.id));\n    }\n\n    const ariaDescribedby = ids.join(' ');\n    if (this._input) {\n      setOrRemoveAttribute(this._input, 'aria-describedby', ariaDescribedby);\n    }\n  }\n\n  /** Manually reset the form field. Currently, this only resets the floating label. */\n  public reset(): void {\n    this._checkAndUpdateInputEmpty();\n  }\n\n  /** Manually clears the input value. It only works for inputs, selects are not supported. */\n  public clear(): void {\n    if ((this._input?.localName as string) !== 'input') {\n      return;\n    }\n    (this._input as { value: string }).value = '';\n    this._checkAndUpdateInputEmpty();\n  }\n\n  /**\n   * Returns the input element.\n   * @deprecated Use the 'inputElement' property instead\n   */\n  public getInputElement(): HTMLInputElement | HTMLSelectElement | HTMLElement | undefined {\n    return this._input;\n  }\n\n  private _syncNegative(): void {\n    this.querySelectorAll?.(\n      'sbb-form-error,sbb-mini-button,sbb-popover-trigger,sbb-form-field-clear,sbb-datepicker-next-day,sbb-datepicker-previous-day,sbb-datepicker-toggle,sbb-select,sbb-autocomplete',\n    ).forEach((element) => element.toggleAttribute('negative', this.negative));\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-form-field__space-wrapper\">\n        ${/* Queried by id from the autocomplete/select to be used as the anchor element */ ''}\n        <div @click=${this._handleWrapperClick} class=\"sbb-form-field__wrapper\" id=\"overlay-anchor\">\n          <slot name=\"prefix\" @slotchange=${this._syncNegative}></slot>\n          <div class=\"sbb-form-field__input-container\">\n            <span class=\"sbb-form-field__label-spacer\" aria-hidden=\"true\"></span>\n            <span class=\"sbb-form-field__label\">\n              <span class=\"sbb-form-field__label-ellipsis\">\n                <slot name=\"label\" @slotchange=${this._onSlotLabelChange}></slot>\n                ${this.optional\n                  ? html` <span aria-hidden=\"true\"> ${i18nOptional[this._language.current]} </span>`\n                  : nothing}\n              </span>\n            </span>\n            <div class=\"sbb-form-field__input\">\n              <slot @slotchange=${this._onSlotInputChange}></slot>\n            </div>\n            ${['select', 'sbb-select'].includes(this._input?.localName as string)\n              ? html`<sbb-icon\n                  name=\"chevron-small-down-small\"\n                  class=\"sbb-form-field__select-input-icon\"\n                ></sbb-icon>`\n              : nothing}\n          </div>\n          <slot name=\"suffix\" @slotchange=${this._syncNegative}></slot>\n        </div>\n\n        <div class=\"sbb-form-field__error\">\n          <slot name=\"error\" @slotchange=${this._onSlotErrorChange}></slot>\n        </div>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-form-field': SbbFormFieldElement;\n  }\n}\n"],"names":[],"mappings":"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"}