@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771859294

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

@@ -0,0 +1,922 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, LitElement, isServer, nothing, html } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+import { sbbInputModalityDetector } from "../../core/a11y.js";
+import { SbbLanguageController } from "../../core/controllers.js";
+import { forceType } from "../../core/decorators.js";
+import { isLean } from "../../core/dom.js";
+import { i18nOptional } from "../../core/i18n.js";
+import { SbbNegativeMixin, SbbElementInternalsMixin, SbbHydrationMixin, removeAriaElements, appendAriaElements } from "../../core/mixins.js";
+import { boxSizingStyles } from "../../core/styles.js";
+import "../../icon.js";
+const style = css`@charset "UTF-8";
+:host {
+  display: inline-block;
+  color: var(--sbb-color-3);
+  --sbb-form-field-background-color: var(--sbb-background-color-1);
+  --sbb-form-field-border-color: var(--sbb-border-color-5);
+  --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-label-color: light-dark(var(--sbb-color-metal), var(--sbb-color-smoke));
+  --sbb-form-field-prefix-color: var(--sbb-color-metal);
+  --sbb-form-field-prefix-color: light-dark(var(--sbb-color-metal), var(--sbb-color-smoke));
+  --sbb-form-field-padding-inline: var(--sbb-spacing-fixed-3x);
+  --sbb-form-field-text-color: var(--sbb-color-3);
+  --sbb-form-field-arrow-color: var(--sbb-color-3);
+  --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-input-text-size: var(--sbb-text-font-size-m);
+  --sbb-form-field-label-text-size: var(--sbb-text-font-size-xs);
+  --sbb-form-field-label-size: calc(
+    var(--sbb-form-field-label-text-size) * var(--sbb-typo-line-height-text)
+  );
+  --sbb-form-field-text-line-height: calc(
+    var(--sbb-form-field-input-text-size) * var(--sbb-typo-line-height-text)
+  );
+  --sbb-form-field-margin-block-start: calc(
+    (
+        var(--sbb-form-field-min-height) - var(--sbb-form-field-label-size) - var(
+            --sbb-form-field-text-line-height
+          ) +
+          var(--sbb-form-field-label-to-input-overlapping)
+      ) /
+      2
+  );
+  --sbb-form-field-spacer-margin-block-end: calc(
+    -1 * var(--sbb-form-field-label-to-input-overlapping)
+  );
+  --sbb-form-field-floating-label-transform: 0.53125rem;
+  --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);
+  --sbb-focus-outline-color: light-dark(
+    var(--sbb-focus-outline-color-default),
+    var(--sbb-focus-outline-color-dark)
+  );
+}
+@media (min-width: calc(64rem)) {
+  :host {
+    --sbb-form-field-floating-label-transform: 0.65625rem;
+  }
+}
+@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]) {
+  color: var(--sbb-color-3-negative);
+  --sbb-form-field-background-color: var(--sbb-background-color-1-negative);
+  --sbb-form-field-border-color: var(--sbb-border-color-5);
+  --sbb-form-field-label-color: var(--sbb-color-5);
+  --sbb-form-field-prefix-color: var(--sbb-color-5);
+  --sbb-form-field-text-color: var(--sbb-color-3-negative);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+  --sbb-form-field-arrow-color: var(--sbb-color-3-negative);
+}
+@media (forced-colors: active) {
+  :host([negative]) {
+    --sbb-form-field-border-color: ButtonBorder;
+  }
+}
+
+:host([size=s]) {
+  --sbb-form-field-min-height: var(--sbb-size-element-xs);
+  --sbb-form-field-padding-inline: var(--sbb-spacing-fixed-2x);
+  --sbb-form-field-input-text-size: var(--sbb-text-font-size-s);
+  --sbb-form-field-label-text-size: var(--sbb-text-font-size-xxs);
+  --sbb-form-field-label-to-input-overlapping: 0.625rem;
+  --sbb-form-field-floating-label-transform: 0.34375rem;
+  --sbb-form-field-spacer-margin-block-end: -0.53125rem;
+}
+@media (min-width: calc(64rem)) {
+  :host([size=s]) {
+    --sbb-form-field-label-to-input-overlapping: 0.6875rem;
+    --sbb-form-field-floating-label-transform: 0.3125rem;
+    --sbb-form-field-spacer-margin-block-end: -0.5rem;
+  }
+}
+
+: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-text) * var(--sbb-text-font-size-xs)
+  );
+  --sbb-form-field-error-padding-block-start-override: var(--sbb-form-field-error-divider-width);
+}
+
+:host(:where(:is(:state(readonly),[state--readonly]), :is(:state(disabled),[state--disabled]))) {
+  --sbb-form-field-background-color: var(--sbb-background-color-3);
+  --sbb-form-field-border-color: var(--sbb-color-graphite);
+  --sbb-form-field-border-color: light-dark(var(--sbb-color-graphite), var(--sbb-color-smoke));
+  --sbb-form-field-arrow-color: var(--sbb-color-granite);
+  --sbb-form-field-arrow-color: light-dark(var(--sbb-color-granite), var(--sbb-color-storm));
+}
+@media (forced-colors: active) {
+  :host(:where(:is(:state(readonly),[state--readonly]), :is(:state(disabled),[state--disabled]))) {
+    --sbb-form-field-border-color: ButtonBorder;
+  }
+}
+
+:host(:where(:is(:state(readonly),[state--readonly]), :is(:state(disabled),[state--disabled]))[negative]) {
+  --sbb-form-field-background-color: var(--sbb-background-color-3-negative);
+  --sbb-form-field-border-color: var(--sbb-border-color-5);
+  --sbb-form-field-arrow-color: var(--sbb-border-color-5);
+}
+
+:host(:where(:is(:state(disabled),[state--disabled]))) {
+  --sbb-form-field-label-color: var(--sbb-color-granite);
+  --sbb-form-field-label-color: light-dark(var(--sbb-color-granite), var(--sbb-color-smoke));
+  --sbb-form-field-prefix-color: var(--sbb-color-granite);
+  --sbb-form-field-prefix-color: light-dark(var(--sbb-color-granite), var(--sbb-color-storm));
+  --sbb-form-field-border-style: dashed;
+}
+@media (forced-colors: active) {
+  :host(:where(:is(:state(disabled),[state--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(:where(:is(:state(disabled),[state--disabled]))[negative]) {
+  --sbb-form-field-text-color: var(--sbb-color-5);
+  --sbb-form-field-label-color: var(--sbb-color-5);
+  --sbb-form-field-prefix-color: var(--sbb-color-5);
+}
+
+:host(:where(:is(:state(readonly),[state--readonly])):not([negative])) {
+  --sbb-form-field-label-color: var(--sbb-color-granite);
+  --sbb-form-field-label-color: light-dark(var(--sbb-color-granite), var(--sbb-color-smoke));
+  --sbb-form-field-prefix-color: var(--sbb-color-granite);
+  --sbb-form-field-prefix-color: light-dark(var(--sbb-color-granite), var(--sbb-color-storm));
+}
+
+:host(:where(:is(:state(focus),[state--focus]))) {
+  --sbb-form-field-border-color: var(--sbb-border-color-3);
+  --sbb-form-field-prefix-color: var(--sbb-color-3);
+  --sbb-form-field-border-width: var(--sbb-border-width-2x);
+}
+
+:host(:where(:is(:state(focus),[state--focus]))[negative]) {
+  --sbb-form-field-border-color: var(--sbb-border-color-3-negative);
+  --sbb-form-field-prefix-color: var(--sbb-color-3-negative);
+}
+
+@media (forced-colors: active) {
+  :host(:is(:state(focus),[state--focus])) {
+    --sbb-form-field-border-color: Highlight;
+    --sbb-form-field-prefix-color: Highlight;
+  }
+}
+
+:host(:not(:where(:is(:state(has-error),[state--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(:is(:state(slotted-label),[state--slotted-label])), [hidden-label])) {
+  --sbb-form-field-label-size: 0rem;
+  --sbb-form-field-label-to-input-overlapping: 0rem;
+}
+
+:host(:where(:is(:state(input-type-sbb-slider),[state--input-type-sbb-slider]))) {
+  --sbb-form-field-overflow: visible;
+}
+
+:host(:where(:is(:state(input-type-textarea),[state--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(:where(:is(:state(focus),[state--focus]):is(:state(focus-origin-keyboard),[state--focus-origin-keyboard]))) .sbb-form-field__wrapper {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+  outline-offset: var(--sbb-form-field-outline-offset, var(--sbb-focus-outline-offset));
+}
+@media (forced-colors: none) {
+  :host(:is([borderless], :is(:state(input-type-sbb-slider),[state--input-type-sbb-slider]))) .sbb-form-field__wrapper::before {
+    border-color: transparent;
+  }
+  :host(:where(:is(:state(focus),[state--focus]), :is(:state(disabled),[state--disabled]))[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;
+    z-index: var(--sbb-form-field-focus-underline-z-index, initial);
+  }
+}
+
+::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(:where(:is(:state(empty),[state--empty]), :is(:state(disabled),[state--disabled]), :is(:state(readonly),[state--readonly]))) ::slotted(sbb-form-field-clear) {
+  display: none;
+}
+
+::slotted(sbb-datepicker-toggle) {
+  padding-block-end: 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-form-field-label-text-size) * var(--sbb-typo-line-height-text));
+  margin-block-end: var(--sbb-form-field-spacer-margin-block-end);
+}
+
+:host(:not(:is(:state(slotted-label),[state--slotted-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-path: rect(0 0 0 0);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+  width: 1px;
+}
+
+.sbb-form-field__label {
+  display: flex;
+  max-width: 100%;
+  cursor: var(--sbb-cursor-default);
+  position: absolute;
+  inset-block-start: 0;
+  color: var(--sbb-form-field-label-color);
+  --sbb-text-font-size: var(--sbb-text-font-size-xs);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+  font-size: var(--sbb-text-font-size);
+}
+:host([size=s]) .sbb-form-field__label {
+  --sbb-text-font-size: var(--sbb-text-font-size-xxs);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+  font-size: var(--sbb-text-font-size);
+}
+:host(:where(:is(:state(input-type-select),[state--input-type-select]), :is(:state(input-type-sbb-select),[state--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-duration, var(--sbb-animation-duration-2x));
+  transition-timing-function: var(--sbb-animation-easing);
+  transition-property: transform, font-size;
+}
+:host([floating-label]:is(:not(:where(:is(:state(focus),[state--focus])):not(:where(:is(:state(input-type-sbb-select),[state--input-type-sbb-select]))),
+:where(:is(:state(has-popup-open),[state--has-popup-open]))),
+:where(:is(:state(readonly),[state--readonly]))):where(:is(:state(empty),[state--empty]))) .sbb-form-field__label {
+  font-size: var(--sbb-form-field-input-text-size);
+  transform: translateY(var(--sbb-form-field-floating-label-transform));
+}
+@media (forced-colors: active) {
+  :host(:where(:is(:state(input-type-textarea),[state--input-type-textarea]))) .sbb-form-field__label {
+    z-index: 1;
+  }
+}
+
+.sbb-form-field__label-ellipsis {
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.sbb-form-field__input {
+  display: flex;
+}
+:host([size=s]:is(:is(:state(input-type-input),[state--input-type-input]),
+:is(:state(input-type-select),[state--input-type-select]),
+:is(:state(input-type-sbb-select),[state--input-type-sbb-select]),
+:is(:state(input-type-sbb-date-input),[state--input-type-sbb-date-input]),
+:is(:state(input-type-sbb-time-input),[state--input-type-sbb-time-input]))) .sbb-form-field__input {
+  margin-block-end: -0.125rem;
+}
+
+.sbb-form-field__error {
+  display: flex;
+  min-height: var(--sbb-form-field-error-min-height);
+  flex-direction: column;
+  margin-block-start: var(--sbb-form-field-error-padding-block-start-override, var(--sbb-form-field-error-padding-block-start));
+}`;
+let nextId = 0;
+const patchedInputs = /* @__PURE__ */ new WeakMap();
+const nativeInputElements = ["input", "textarea", "select"];
+class SbbFormFieldControlEvent extends Event {
+  get control() {
+    return this._control;
+  }
+  constructor(control) {
+    super("formfieldcontrol");
+    this._control = control;
+  }
+}
+let SbbFormFieldElement = (() => {
+  var _errorSpace_accessor_storage, _optional_accessor_storage, _size_accessor_storage, _borderless_accessor_storage, _width_accessor_storage, _hiddenLabel_accessor_storage, _floatingLabel_accessor_storage, __errorElements_accessor_storage, __input_accessor_storage, __label_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-form-field")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbNegativeMixin(SbbElementInternalsMixin(SbbHydrationMixin(LitElement)));
+  let _errorSpace_decorators;
+  let _errorSpace_initializers = [];
+  let _errorSpace_extraInitializers = [];
+  let _optional_decorators;
+  let _optional_initializers = [];
+  let _optional_extraInitializers = [];
+  let _size_decorators;
+  let _size_initializers = [];
+  let _size_extraInitializers = [];
+  let _borderless_decorators;
+  let _borderless_initializers = [];
+  let _borderless_extraInitializers = [];
+  let _width_decorators;
+  let _width_initializers = [];
+  let _width_extraInitializers = [];
+  let _hiddenLabel_decorators;
+  let _hiddenLabel_initializers = [];
+  let _hiddenLabel_extraInitializers = [];
+  let _floatingLabel_decorators;
+  let _floatingLabel_initializers = [];
+  let _floatingLabel_extraInitializers = [];
+  let __errorElements_decorators;
+  let __errorElements_initializers = [];
+  let __errorElements_extraInitializers = [];
+  let __input_decorators;
+  let __input_initializers = [];
+  let __input_extraInitializers = [];
+  let __label_decorators;
+  let __label_initializers = [];
+  let __label_extraInitializers = [];
+  _a = class extends _classSuper {
+    constructor() {
+      super();
+      __privateAdd(this, _errorSpace_accessor_storage);
+      __privateAdd(this, _optional_accessor_storage);
+      __privateAdd(this, _size_accessor_storage);
+      __privateAdd(this, _borderless_accessor_storage);
+      __privateAdd(this, _width_accessor_storage);
+      __privateAdd(this, _hiddenLabel_accessor_storage);
+      __privateAdd(this, _floatingLabel_accessor_storage);
+      __privateAdd(this, __errorElements_accessor_storage);
+      __privateAdd(this, __input_accessor_storage);
+      __privateAdd(this, __label_accessor_storage);
+      this._excludedFocusElements = ["button", "sbb-popover", "sbb-option", "sbb-chip"];
+      this._floatingLabelSupportedInputElements = [
+        "input",
+        "select",
+        "textarea",
+        "sbb-select"
+      ];
+      this._floatingLabelSupportedInputTypes = [
+        "email",
+        "number",
+        "password",
+        "search",
+        "tel",
+        "text",
+        "url"
+      ];
+      __privateSet(this, _errorSpace_accessor_storage, __runInitializers(this, _errorSpace_initializers, "none"));
+      __privateSet(this, _optional_accessor_storage, (__runInitializers(this, _errorSpace_extraInitializers), __runInitializers(this, _optional_initializers, false)));
+      __privateSet(this, _size_accessor_storage, (__runInitializers(this, _optional_extraInitializers), __runInitializers(this, _size_initializers, isLean() ? "s" : "m")));
+      __privateSet(this, _borderless_accessor_storage, (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _borderless_initializers, false)));
+      __privateSet(this, _width_accessor_storage, (__runInitializers(this, _borderless_extraInitializers), __runInitializers(this, _width_initializers, "default")));
+      __privateSet(this, _hiddenLabel_accessor_storage, (__runInitializers(this, _width_extraInitializers), __runInitializers(this, _hiddenLabel_initializers, false)));
+      __privateSet(this, _floatingLabel_accessor_storage, (__runInitializers(this, _hiddenLabel_extraInitializers), __runInitializers(this, _floatingLabel_initializers, false)));
+      __privateSet(this, __errorElements_accessor_storage, (__runInitializers(this, _floatingLabel_extraInitializers), __runInitializers(this, __errorElements_initializers, [])));
+      __privateSet(this, __input_accessor_storage, (__runInitializers(this, __errorElements_extraInitializers), __runInitializers(this, __input_initializers, null)));
+      __privateSet(this, __label_accessor_storage, (__runInitializers(this, __input_extraInitializers), __runInitializers(this, __label_initializers, void 0)));
+      this._language = (__runInitializers(this, __label_extraInitializers), new SbbLanguageController(this));
+      this._formFieldAttributeObserver = !isServer ? new MutationObserver((mutations) => {
+        if (mutations.some((m) => m.type === "attributes") && this._input) {
+          this._readInputState();
+          this._registerInputFormListener();
+          this._checkAndUpdateInputEmpty();
+        }
+      }) : null;
+      this._inputFormAbortController = new AbortController();
+      this._control = null;
+      this.addEventListener?.("focusin", (event) => {
+        if (event.target === this.inputElement || event.target === this.inputElement?.inputElement) {
+          this.internals.states.add("focus");
+          this.internals.states.add(`focus-origin-${sbbInputModalityDetector.mostRecentModality}`);
+        }
+      }, { passive: true });
+      this.addEventListener?.("focusout", (event) => {
+        if (event.target === this.inputElement || event.target === this.inputElement?.inputElement) {
+          this._checkAndUpdateInputEmpty();
+          this.internals.states.delete("focus");
+          for (const state2 of this.internals.states) {
+            if (state2.startsWith("focus-origin-")) {
+              this.internals.states.delete(state2);
+            }
+          }
+        }
+      }, { passive: true });
+      this.addEventListener("input", () => this._checkAndUpdateInputEmpty());
+      this.addEventListener("displayvaluechange", () => this._checkAndUpdateInputEmpty());
+      this.addEventListener("invalid", (e) => e.preventDefault(), { capture: true });
+      this.addEventListener("formfieldcontrol", (e) => {
+        this._control = e.control;
+        if (this._connectInputElement() === "unchanged") {
+          this._assignErrorMessageElements();
+          this._readInputState();
+          this._checkAndUpdateInputEmpty();
+        }
+      });
+    }
+    /**
+     * Whether to reserve space for an error message.
+     * `none` does not reserve any space.
+     * `reserve` does reserve one row for an error message.
+     */
+    get errorSpace() {
+      return __privateGet(this, _errorSpace_accessor_storage);
+    }
+    set errorSpace(value) {
+      __privateSet(this, _errorSpace_accessor_storage, value);
+    }
+    /** Indicates whether the input is optional. */
+    get optional() {
+      return __privateGet(this, _optional_accessor_storage);
+    }
+    set optional(value) {
+      __privateSet(this, _optional_accessor_storage, value);
+    }
+    /**
+     * Size variant, either l, m or s.
+     * @default 'm' / 's' (lean)
+     */
+    get size() {
+      return __privateGet(this, _size_accessor_storage);
+    }
+    set size(value) {
+      __privateSet(this, _size_accessor_storage, value);
+    }
+    /** Whether to display the form field without a border. */
+    get borderless() {
+      return __privateGet(this, _borderless_accessor_storage);
+    }
+    set borderless(value) {
+      __privateSet(this, _borderless_accessor_storage, value);
+    }
+    /** Defines the width of the component:
+     * - `default`: the component has defined width and min-width;
+     * - `collapse`: the component adapts itself to its inner input content. */
+    get width() {
+      return __privateGet(this, _width_accessor_storage);
+    }
+    set width(value) {
+      __privateSet(this, _width_accessor_storage, value);
+    }
+    /** Whether to visually hide the label. If hidden, screen readers will still read it. */
+    get hiddenLabel() {
+      return __privateGet(this, _hiddenLabel_accessor_storage);
+    }
+    set hiddenLabel(value) {
+      __privateSet(this, _hiddenLabel_accessor_storage, value);
+    }
+    /** Whether the label should float. If activated, the placeholder of the input is hidden. */
+    get floatingLabel() {
+      return __privateGet(this, _floatingLabel_accessor_storage);
+    }
+    set floatingLabel(value) {
+      __privateSet(this, _floatingLabel_accessor_storage, value);
+    }
+    /** It is used internally to get the `error` slot. */
+    get _errorElements() {
+      return __privateGet(this, __errorElements_accessor_storage);
+    }
+    set _errorElements(value) {
+      __privateSet(this, __errorElements_accessor_storage, value);
+    }
+    /** Reference to the slotted input element. */
+    get _input() {
+      return __privateGet(this, __input_accessor_storage);
+    }
+    set _input(value) {
+      __privateSet(this, __input_accessor_storage, value);
+    }
+    /** Reference to the slotted label elements. */
+    get _label() {
+      return __privateGet(this, __label_accessor_storage);
+    }
+    set _label(value) {
+      __privateSet(this, __label_accessor_storage, value);
+    }
+    /** Returns the input element. */
+    get inputElement() {
+      return this._input;
+    }
+    /** Reference to the slotted label. */
+    get label() {
+      return this._label;
+    }
+    connectedCallback() {
+      super.connectedCallback();
+      this._assignSlots();
+      this._connectInputElement();
+      this._syncNegative();
+      this._syncSize();
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("negative")) {
+        this._syncNegative();
+      }
+      if (changedProperties.has("size")) {
+        this._syncSize();
+      }
+    }
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this._formFieldAttributeObserver?.disconnect();
+      this._inputFormAbortController.abort();
+      if (this._input?.localName === "input") {
+        this._unpatchInputValue();
+      }
+    }
+    _handleWrapperClick(event) {
+      if (this._isElementFocusExcluded(event)) {
+        return;
+      }
+      if (this._control?.onContainerClick) {
+        this._control?.onContainerClick(event);
+      } else if (event.target.localName !== "label") {
+        if (this._input?.localName === "sbb-select" && event.target.localName !== "sbb-select") {
+          this._input.click();
+        }
+        this._input?.focus();
+      }
+    }
+    _isElementFocusExcluded(event) {
+      return event.composedPath().some((el) => el instanceof window.HTMLElement && (el.getAttribute("tabindex") === "0" || el.hasAttribute("contenteditable")) || this._excludedFocusElements.includes(el.localName));
+    }
+    _onSlotLabelChange() {
+      const labels = Array.from(this.querySelectorAll("label"));
+      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() {
+      this._assignSlots();
+      this._connectInputElement();
+    }
+    _assignSlots() {
+      this.querySelectorAll("label:not([slot])").forEach((e) => e.setAttribute("slot", "label"));
+      this.querySelectorAll("sbb-error:not([slot])").forEach((e) => e.setAttribute("slot", "error"));
+    }
+    _connectInputElement() {
+      let newInput;
+      if (this._control?.id) {
+        newInput = this.getRootNode().getElementById(this._control.id);
+      } else {
+        const inputCandidates = Array.from(this.querySelectorAll("*:not([slot],sbb-chip-group)"));
+        newInput = (inputCandidates.find((e) => this._isInputElement(e)) || inputCandidates[0]) ?? null;
+      }
+      if (newInput === this._input) {
+        return "unchanged";
+      } else if (this._input) {
+        this.internals.states.delete(`input-type-${this._input.localName}`);
+        if (this._input.localName === "input") {
+          this._unpatchInputValue();
+        }
+      }
+      if (!newInput) {
+        this._input = null;
+        return "no-input";
+      }
+      this._input = newInput;
+      this._registerInputFormListener();
+      this._assignErrorMessageElements();
+      this._readInputState();
+      this._checkAndUpdateInputEmpty();
+      if (this._input.localName === "textarea") {
+        this._input.setAttribute("rows", this._input.getAttribute("rows") || "3");
+      } else if (this._input.localName === "input") {
+        this._patchInputValue();
+      } else if ((this._input.localName === "select" || this._input.localName === "sbb-select") && !this.hasUpdated) {
+        this.hydrationComplete.then(() => this.requestUpdate());
+      }
+      this._formFieldAttributeObserver?.disconnect();
+      this._formFieldAttributeObserver?.observe(this._input, {
+        attributes: true,
+        attributeFilter: ["readonly", "disabled", "form", "class", "data-expanded"]
+      });
+      this.internals.states.add(`input-type-${this._input.localName}`);
+      this._syncLabelInputReferences();
+      return "changed";
+    }
+    _syncLabelInputReferences() {
+      if (!this._input || !this._label) {
+        return;
+      }
+      if (nativeInputElements.includes(this._input.localName) || customElements.get(this._input.localName)?.formAssociated) {
+        this._input.id ||= `sbb-form-field-input-${nextId++}`;
+        this._label.htmlFor = this._input.id;
+      } else {
+        this._label.id ||= `sbb-form-field-label-${nextId++}`;
+        const labelledby = this._input.getAttribute("aria-labelledby")?.split(" ").filter((l) => !!l && l !== this._label.id) ?? [];
+        this._input.setAttribute("aria-labelledby", [...labelledby, this._label.id].join(" "));
+      }
+    }
+    _isInputElement(input) {
+      return nativeInputElements.includes(input.localName) || !!customElements.get(input.localName)?.formAssociated;
+    }
+    _readInputState() {
+      this.toggleState("readonly", this._control?.readOnly ?? this._input.hasAttribute("readonly"));
+      this.toggleState("disabled", this._control?.disabled ?? this._input.hasAttribute("disabled"));
+      this.toggleState("has-popup-open", this._input.hasAttribute("data-expanded"));
+    }
+    _registerInputFormListener() {
+      this._inputFormAbortController.abort();
+      const { signal } = this._inputFormAbortController = new AbortController();
+      const form = this._input?.form ?? this._input?.closest("form");
+      const resetHandler = () => setTimeout(() => this.reset());
+      form?.addEventListener("reset", resetHandler, { signal });
+    }
+    // We need to patch the value property of the HTMLInputElement in order
+    // to be able to reset the floating label in the empty state.
+    _patchInputValue() {
+      const inputElement = this._input;
+      if (!inputElement || patchedInputs.has(inputElement)) {
+        return;
+      }
+      const originalDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(inputElement), "value");
+      if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.get) {
+        return;
+      }
+      patchedInputs.set(inputElement, originalDescriptor);
+      const { get: getter, set: setter } = originalDescriptor;
+      const checkAndUpdateInputEmpty = () => this._checkAndUpdateInputEmpty();
+      Object.defineProperty(inputElement, "value", {
+        ...originalDescriptor,
+        get() {
+          return getter.call(this);
+        },
+        set(newValue) {
+          setter.call(this, newValue);
+          checkAndUpdateInputEmpty();
+        }
+      });
+    }
+    _unpatchInputValue() {
+      const inputElement = this._input;
+      const originalDescriptor = patchedInputs.get(inputElement);
+      if (originalDescriptor) {
+        Object.defineProperty(inputElement, "value", originalDescriptor);
+        patchedInputs.delete(inputElement);
+      }
+    }
+    _checkAndUpdateInputEmpty() {
+      this.toggleState("empty", this._control?.empty ?? (((this._floatingLabelSupportedInputElements.includes(this._input?.localName) || this._input?.constructor?.formFieldAssociated) ?? false) && this._isInputEmpty()));
+    }
+    _isInputEmpty() {
+      const chipGroupElem = this.querySelector("sbb-chip-group");
+      if (chipGroupElem) {
+        return this._isInputValueEmpty() && (Array.isArray(chipGroupElem.value) ? chipGroupElem.value.length === 0 : !chipGroupElem.querySelector("sbb-chip"));
+      } else if (this._input instanceof HTMLInputElement) {
+        return this._floatingLabelSupportedInputTypes.includes(this._input.type) && this._isInputValueEmpty();
+      } else if (this._input instanceof HTMLSelectElement) {
+        return this._input.selectedOptions?.item(0)?.label?.trim() === "";
+      } else if (this._input?.localName === "sbb-select") {
+        return this._input.getDisplayValue?.()?.trim() === "";
+      } else {
+        return this._isInputValueEmpty();
+      }
+    }
+    _isInputValueEmpty() {
+      const value = this._input.value;
+      return ["", void 0, null].includes(value) || Array.isArray(value) && value.length === 0;
+    }
+    /**
+     * It is used internally to set the aria-describedby attribute for the slotted input referencing available <sbb-error> instances.
+     */
+    _onSlotErrorChange(event) {
+      const errorElements = event.target.assignedElements();
+      if (this._input && this._input.ariaDescribedByElements?.length) {
+        this._input.ariaDescribedByElements = removeAriaElements(this._input.ariaDescribedByElements, ...this._errorElements ?? []);
+      }
+      this._errorElements = errorElements;
+      for (const el of this._errorElements) {
+        el.role ||= "status";
+      }
+      this._assignErrorMessageElements();
+      this.toggleState("has-error", !!this._errorElements.length);
+      this._syncNegative();
+    }
+    _assignErrorMessageElements() {
+      if (this._input) {
+        this._input.ariaDescribedByElements = appendAriaElements(this._input.ariaDescribedByElements, ...this._errorElements);
+      }
+    }
+    /** 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() {
+      if (this._input?.localName !== "input") {
+        return;
+      }
+      this._input.value = "";
+      this._checkAndUpdateInputEmpty();
+    }
+    _syncNegative() {
+      this.querySelectorAll?.("sbb-error,sbb-mini-button,sbb-mini-button-link,sbb-form-field-clear,sbb-datepicker-next-day,sbb-datepicker-previous-day,sbb-datepicker-toggle,sbb-select,sbb-autocomplete,sbb-autocomplete-grid,sbb-chip-group").forEach((element) => element.toggleAttribute("negative", this.negative));
+    }
+    _syncSize() {
+      this.querySelectorAll?.("sbb-autocomplete,sbb-autocomplete-grid,sbb-select").forEach((element) => element.size = this.size === "s" ? "s" : "m");
+    }
+    render() {
+      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>
+            ${this.hasUpdated && ["select", "sbb-select"].includes(this._input?.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>
+    `;
+    }
+  }, _errorSpace_accessor_storage = new WeakMap(), _optional_accessor_storage = new WeakMap(), _size_accessor_storage = new WeakMap(), _borderless_accessor_storage = new WeakMap(), _width_accessor_storage = new WeakMap(), _hiddenLabel_accessor_storage = new WeakMap(), _floatingLabel_accessor_storage = new WeakMap(), __errorElements_accessor_storage = new WeakMap(), __input_accessor_storage = new WeakMap(), __label_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _errorSpace_decorators = [property({ attribute: "error-space", reflect: true })];
+    _optional_decorators = [forceType(), property({ type: Boolean })];
+    _size_decorators = [property({ reflect: true })];
+    _borderless_decorators = [forceType(), property({ reflect: true, type: Boolean })];
+    _width_decorators = [property({ reflect: true })];
+    _hiddenLabel_decorators = [forceType(), property({ attribute: "hidden-label", reflect: true, type: Boolean })];
+    _floatingLabel_decorators = [forceType(), property({ attribute: "floating-label", reflect: true, type: Boolean })];
+    __errorElements_decorators = [state()];
+    __input_decorators = [state()];
+    __label_decorators = [state()];
+    __esDecorate(_a, null, _errorSpace_decorators, { kind: "accessor", name: "errorSpace", static: false, private: false, access: { has: (obj) => "errorSpace" in obj, get: (obj) => obj.errorSpace, set: (obj, value) => {
+      obj.errorSpace = value;
+    } }, metadata: _metadata }, _errorSpace_initializers, _errorSpace_extraInitializers);
+    __esDecorate(_a, null, _optional_decorators, { kind: "accessor", name: "optional", static: false, private: false, access: { has: (obj) => "optional" in obj, get: (obj) => obj.optional, set: (obj, value) => {
+      obj.optional = value;
+    } }, metadata: _metadata }, _optional_initializers, _optional_extraInitializers);
+    __esDecorate(_a, null, _size_decorators, { kind: "accessor", name: "size", static: false, private: false, access: { has: (obj) => "size" in obj, get: (obj) => obj.size, set: (obj, value) => {
+      obj.size = value;
+    } }, metadata: _metadata }, _size_initializers, _size_extraInitializers);
+    __esDecorate(_a, null, _borderless_decorators, { kind: "accessor", name: "borderless", static: false, private: false, access: { has: (obj) => "borderless" in obj, get: (obj) => obj.borderless, set: (obj, value) => {
+      obj.borderless = value;
+    } }, metadata: _metadata }, _borderless_initializers, _borderless_extraInitializers);
+    __esDecorate(_a, null, _width_decorators, { kind: "accessor", name: "width", static: false, private: false, access: { has: (obj) => "width" in obj, get: (obj) => obj.width, set: (obj, value) => {
+      obj.width = value;
+    } }, metadata: _metadata }, _width_initializers, _width_extraInitializers);
+    __esDecorate(_a, null, _hiddenLabel_decorators, { kind: "accessor", name: "hiddenLabel", static: false, private: false, access: { has: (obj) => "hiddenLabel" in obj, get: (obj) => obj.hiddenLabel, set: (obj, value) => {
+      obj.hiddenLabel = value;
+    } }, metadata: _metadata }, _hiddenLabel_initializers, _hiddenLabel_extraInitializers);
+    __esDecorate(_a, null, _floatingLabel_decorators, { kind: "accessor", name: "floatingLabel", static: false, private: false, access: { has: (obj) => "floatingLabel" in obj, get: (obj) => obj.floatingLabel, set: (obj, value) => {
+      obj.floatingLabel = value;
+    } }, metadata: _metadata }, _floatingLabel_initializers, _floatingLabel_extraInitializers);
+    __esDecorate(_a, null, __errorElements_decorators, { kind: "accessor", name: "_errorElements", static: false, private: false, access: { has: (obj) => "_errorElements" in obj, get: (obj) => obj._errorElements, set: (obj, value) => {
+      obj._errorElements = value;
+    } }, metadata: _metadata }, __errorElements_initializers, __errorElements_extraInitializers);
+    __esDecorate(_a, null, __input_decorators, { kind: "accessor", name: "_input", static: false, private: false, access: { has: (obj) => "_input" in obj, get: (obj) => obj._input, set: (obj, value) => {
+      obj._input = value;
+    } }, metadata: _metadata }, __input_initializers, __input_extraInitializers);
+    __esDecorate(_a, null, __label_decorators, { kind: "accessor", name: "_label", static: false, private: false, access: { has: (obj) => "_label" in obj, get: (obj) => obj._label, set: (obj, value) => {
+      obj._label = value;
+    } }, metadata: _metadata }, __label_initializers, __label_extraInitializers);
+    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+    _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = [boxSizingStyles, style], __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+export {
+  SbbFormFieldControlEvent,
+  SbbFormFieldElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-field.component.js","sources":["../../../../../src/elements/form-field/form-field/form-field.component.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  LitElement,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\n\nimport type { SbbAutocompleteBaseElement } from '../../autocomplete.ts';\nimport type { SbbChipGroupElement } from '../../chip.ts';\nimport { sbbInputModalityDetector } from '../../core/a11y.ts';\nimport { SbbLanguageController } from '../../core/controllers.ts';\nimport { forceType } from '../../core/decorators.ts';\nimport { isLean } from '../../core/dom.ts';\nimport { i18nOptional } from '../../core/i18n.ts';\nimport {\n  appendAriaElements,\n  removeAriaElements,\n  SbbElementInternalsMixin,\n  type SbbFormAssociatedInputMixinType,\n  SbbHydrationMixin,\n  SbbNegativeMixin,\n} from '../../core/mixins.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport type { SbbSelectElement } from '../../select.ts';\n\nimport style from './form-field.scss?lit&inline';\n\nimport '../../icon.ts';\n\nlet nextId = 0;\n\nconst patchedInputs = new WeakMap<HTMLInputElement, PropertyDescriptor>();\nconst nativeInputElements = ['input', 'textarea', 'select'];\n\n/** An interface which allows a control to work inside a `SbbFormField`. */\nexport interface SbbFormFieldElementControl {\n  /** The id of the form field control. */\n  readonly id: string;\n  /** Whether the control is empty. */\n  readonly empty: boolean;\n  /** Whether the control is readonly. */\n  readonly readOnly?: boolean;\n  /** Whether the control is disabled. */\n  readonly disabled: boolean;\n\n  /**\n   * Handles a click on the control's container.\n   * If not implemented, focus() of the element is called.\n   */\n  onContainerClick?(event: MouseEvent): void;\n}\n\nexport class SbbFormFieldControlEvent extends Event {\n  private _control: SbbFormFieldElementControl | null;\n\n  public get control(): SbbFormFieldElementControl | null {\n    return this._control;\n  }\n\n  public constructor(control: SbbFormFieldElementControl | null) {\n    super('formfieldcontrol');\n    this._control = control;\n  }\n}\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 * @cssprop [--sbb-form-field-outline-offset] - To override the focus outline offset,\n * @cssprop [--sbb-form-field-focus-underline-z-index] - To override the z-index of the focus underline effect,\n */\nexport\n@customElement('sbb-form-field')\nclass SbbFormFieldElement extends SbbNegativeMixin(\n  SbbElementInternalsMixin(SbbHydrationMixin(LitElement)),\n) {\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n\n  // List of elements that should not focus input on click\n  private readonly _excludedFocusElements = ['button', 'sbb-popover', 'sbb-option', 'sbb-chip'];\n\n  private readonly _floatingLabelSupportedInputElements = [\n    'input',\n    'select',\n    'textarea',\n    'sbb-select',\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 accessor errorSpace: 'none' | 'reserve' = 'none';\n\n  /** Indicates whether the input is optional. */\n  @forceType()\n  @property({ type: Boolean })\n  public accessor optional: boolean = false;\n\n  /**\n   * Size variant, either l, m or s.\n   * @default 'm' / 's' (lean)\n   */\n  @property({ reflect: true }) public accessor size: 'l' | 'm' | 's' = isLean() ? 's' : 'm';\n\n  /** Whether to display the form field without a border. */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor borderless: boolean = 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 accessor width: 'default' | 'collapse' = 'default';\n\n  /** Whether to visually hide the label. If hidden, screen readers will still read it. */\n  @forceType()\n  @property({ attribute: 'hidden-label', reflect: true, type: Boolean })\n  public accessor hiddenLabel: boolean = false;\n\n  /** Whether the label should float. If activated, the placeholder of the input is hidden. */\n  @forceType()\n  @property({ attribute: 'floating-label', reflect: true, type: Boolean })\n  public accessor floatingLabel: boolean = false;\n\n  /** It is used internally to get the `error` slot. */\n  @state() private accessor _errorElements: Element[] = [];\n\n  /** Reference to the slotted input element. */\n  @state() private accessor _input: HTMLInputElement | HTMLSelectElement | HTMLElement | null =\n    null;\n\n  /** Reference to the slotted label elements. */\n  @state() private accessor _label!: HTMLLabelElement;\n\n  /** Returns the input element. */\n  public get inputElement(): HTMLInputElement | HTMLSelectElement | HTMLElement | null {\n    return this._input;\n  }\n\n  /** Reference to the slotted label. */\n  public get label(): HTMLLabelElement | null {\n    return this._label;\n  }\n\n  private _language = new SbbLanguageController(this);\n\n  /**\n   * Listens to the changes on `readonly` and `disabled` attributes of `<input>`.\n   */\n  private _formFieldAttributeObserver = !isServer\n    ? new MutationObserver((mutations: MutationRecord[]) => {\n        if (mutations.some((m) => m.type === 'attributes') && this._input) {\n          this._readInputState();\n          this._registerInputFormListener();\n          this._checkAndUpdateInputEmpty();\n        }\n      })\n    : null;\n\n  private _inputFormAbortController = new AbortController();\n  private _control: SbbFormFieldElementControl | null = null;\n\n  public constructor() {\n    super();\n    this.addEventListener?.(\n      'focusin',\n      (event) => {\n        if (\n          event.target === this.inputElement ||\n          event.target === (this.inputElement as SbbSelectElement | undefined)?.inputElement\n        ) {\n          this.internals.states.add('focus');\n          this.internals.states.add(`focus-origin-${sbbInputModalityDetector.mostRecentModality}`);\n        }\n      },\n      { passive: true },\n    );\n    this.addEventListener?.(\n      'focusout',\n      (event) => {\n        if (\n          event.target === this.inputElement ||\n          event.target === (this.inputElement as SbbSelectElement | undefined)?.inputElement\n        ) {\n          this._checkAndUpdateInputEmpty();\n          this.internals.states.delete('focus');\n          for (const state of this.internals.states) {\n            if (state.startsWith('focus-origin-')) {\n              this.internals.states.delete(state);\n            }\n          }\n        }\n      },\n      { passive: true },\n    );\n    this.addEventListener('input', () => this._checkAndUpdateInputEmpty());\n    this.addEventListener('displayvaluechange', () => this._checkAndUpdateInputEmpty());\n    // We want to prevent the native browser validation message popover\n    // to be shown. This also prevents a bug in WebKit, which would not\n    // allow host as the validity anchor: https://bugs.webkit.org/show_bug.cgi?id=269832\n    // This is duplicated from the form associated mixin for the native\n    // input controls (e.g. <input> or <select>).\n    this.addEventListener('invalid', (e) => e.preventDefault(), { capture: true });\n    this.addEventListener('formfieldcontrol', (e: SbbFormFieldControlEvent) => {\n      this._control = e.control;\n      if (this._connectInputElement() === 'unchanged') {\n        this._assignErrorMessageElements();\n        this._readInputState();\n        this._checkAndUpdateInputEmpty();\n      }\n    });\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this._assignSlots();\n    this._connectInputElement();\n    this._syncNegative();\n    this._syncSize();\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    if (changedProperties.has('size')) {\n      this._syncSize();\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._formFieldAttributeObserver?.disconnect();\n    this._inputFormAbortController.abort();\n    if (this._input?.localName === 'input') {\n      this._unpatchInputValue();\n    }\n  }\n\n  private _handleWrapperClick(event: MouseEvent): void {\n    if (this._isElementFocusExcluded(event)) {\n      return;\n    }\n\n    if (this._control?.onContainerClick) {\n      this._control?.onContainerClick(event);\n    } else if ((event.target as Element).localName !== 'label') {\n      if (\n        this._input?.localName === 'sbb-select' &&\n        (event.target as HTMLElement).localName !== 'sbb-select'\n      ) {\n        this._input.click();\n      }\n      this._input?.focus();\n    }\n  }\n\n  private _isElementFocusExcluded(event: Event): boolean {\n    return event\n      .composedPath()\n      .some(\n        (el) =>\n          (el instanceof window.HTMLElement &&\n            (el.getAttribute('tabindex') === '0' || el.hasAttribute('contenteditable'))) ||\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(): void {\n    this._assignSlots();\n    this._connectInputElement();\n  }\n\n  private _assignSlots(): void {\n    this.querySelectorAll('label:not([slot])').forEach((e) => e.setAttribute('slot', 'label'));\n    this.querySelectorAll('sbb-error:not([slot])').forEach((e) => e.setAttribute('slot', 'error'));\n  }\n\n  private _connectInputElement(): 'changed' | 'no-input' | 'unchanged' {\n    let newInput: HTMLElement | null;\n    if (this._control?.id) {\n      newInput = (this.getRootNode() as Document | ShadowRoot).getElementById(this._control.id);\n    } else {\n      // Find the slotted input element, even if it's nested (e.g. chip group)\n      const inputCandidates = Array.from(\n        this.querySelectorAll<HTMLElement>('*:not([slot],sbb-chip-group)'),\n      );\n      newInput =\n        (inputCandidates.find((e) => this._isInputElement(e)) || inputCandidates[0]) ?? null;\n    }\n\n    if (newInput === this._input) {\n      return 'unchanged';\n    } else if (this._input) {\n      this.internals.states.delete(`input-type-${this._input.localName}`);\n      if (this._input.localName === 'input') {\n        this._unpatchInputValue();\n      }\n    }\n\n    if (!newInput) {\n      this._input = null;\n      return 'no-input';\n    }\n\n    this._input = newInput;\n    this._registerInputFormListener();\n    this._assignErrorMessageElements();\n    this._readInputState();\n    this._checkAndUpdateInputEmpty();\n\n    if (this._input.localName === 'textarea') {\n      this._input.setAttribute('rows', this._input.getAttribute('rows') || '3');\n    } else if (this._input.localName === 'input') {\n      this._patchInputValue();\n    } else if (\n      (this._input.localName === 'select' || this._input.localName === 'sbb-select') &&\n      !this.hasUpdated\n    ) {\n      // Due to SSR the dropdown icon for selects cannot be rendered in the first render pass.\n      // Due to this we schedule a re-render to render the icon.\n      this.hydrationComplete.then(() => this.requestUpdate());\n    }\n\n    this._formFieldAttributeObserver?.disconnect();\n    this._formFieldAttributeObserver?.observe(this._input, {\n      attributes: true,\n      attributeFilter: ['readonly', 'disabled', 'form', 'class', 'data-expanded'],\n    });\n    this.internals.states.add(`input-type-${this._input.localName}`);\n    this._syncLabelInputReferences();\n    return 'changed';\n  }\n\n  private _syncLabelInputReferences(): void {\n    if (!this._input || !this._label) {\n      return;\n    }\n\n    if (\n      nativeInputElements.includes(this._input.localName) ||\n      (customElements.get(this._input.localName) as { formAssociated: boolean } | undefined)\n        ?.formAssociated\n    ) {\n      // For native input elements we use the `for` attribute on the label to reference the input\n      // via id reference.\n      this._input.id ||= `sbb-form-field-input-${nextId++}`;\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      // TODO: Migrate to ariaLabelledByElements when available:\n      // https://developer.mozilla.org/en-US/docs/Web/API/Element/ariaLabelledByElements\n      this._label.id ||= `sbb-form-field-label-${nextId++}`;\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 _isInputElement(input: Element): boolean {\n    return (\n      nativeInputElements.includes(input.localName) ||\n      !!(customElements.get(input.localName) as { formAssociated: boolean } | undefined)\n        ?.formAssociated\n    );\n  }\n\n  private _readInputState(): void {\n    this.toggleState('readonly', this._control?.readOnly ?? this._input!.hasAttribute('readonly'));\n    this.toggleState('disabled', this._control?.disabled ?? this._input!.hasAttribute('disabled'));\n    this.toggleState('has-popup-open', this._input!.hasAttribute('data-expanded'));\n  }\n\n  private _registerInputFormListener(): void {\n    this._inputFormAbortController.abort();\n    const { signal } = (this._inputFormAbortController = new AbortController());\n\n    const form =\n      (this._input as HTMLInputElement | HTMLSelectElement | undefined)?.form ??\n      this._input?.closest('form');\n    // Timeout needed to have value updated\n    const resetHandler = (): unknown => setTimeout(() => this.reset());\n    form?.addEventListener('reset', resetHandler, { signal });\n  }\n\n  // We need to patch the value property of the HTMLInputElement in order\n  // to be able to reset the floating label in the empty state.\n  private _patchInputValue(): void {\n    const inputElement = this._input as HTMLInputElement;\n    if (!inputElement || patchedInputs.has(inputElement)) {\n      return;\n    }\n\n    const originalDescriptor = Object.getOwnPropertyDescriptor(\n      Object.getPrototypeOf(inputElement),\n      'value',\n    );\n\n    if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.get) {\n      return;\n    }\n\n    patchedInputs.set(inputElement, originalDescriptor);\n\n    const { get: getter, set: setter } = originalDescriptor;\n    const checkAndUpdateInputEmpty = (): void => this._checkAndUpdateInputEmpty();\n\n    Object.defineProperty(inputElement, 'value', {\n      ...originalDescriptor,\n      get() {\n        return getter.call(this);\n      },\n      set(newValue) {\n        setter.call(this, newValue);\n        checkAndUpdateInputEmpty();\n      },\n    });\n  }\n\n  private _unpatchInputValue(): void {\n    const inputElement = this._input as HTMLInputElement;\n    const originalDescriptor = patchedInputs.get(inputElement);\n    if (originalDescriptor) {\n      Object.defineProperty(inputElement, 'value', originalDescriptor);\n      patchedInputs.delete(inputElement);\n    }\n  }\n\n  private _checkAndUpdateInputEmpty(): void {\n    this.toggleState(\n      'empty',\n      this._control?.empty ??\n        (((this._floatingLabelSupportedInputElements.includes(this._input?.localName as string) ||\n          (this._input?.constructor as undefined | typeof SbbFormAssociatedInputMixinType)\n            ?.formFieldAssociated) ??\n          false) &&\n          this._isInputEmpty()),\n    );\n  }\n\n  private _isInputEmpty(): boolean {\n    const chipGroupElem: SbbChipGroupElement | null = this.querySelector('sbb-chip-group');\n    if (chipGroupElem) {\n      return (\n        this._isInputValueEmpty() &&\n        (Array.isArray(chipGroupElem.value)\n          ? chipGroupElem.value.length === 0\n          : !chipGroupElem.querySelector('sbb-chip'))\n      );\n    } else 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  /**\n   * It is used internally to set the aria-describedby attribute for the slotted input referencing available <sbb-error> instances.\n   */\n  private _onSlotErrorChange(event: Event): void {\n    const errorElements = (event.target as HTMLSlotElement).assignedElements();\n    if (this._input && this._input.ariaDescribedByElements?.length) {\n      this._input.ariaDescribedByElements = removeAriaElements(\n        this._input.ariaDescribedByElements,\n        ...(this._errorElements ?? []),\n      );\n    }\n\n    this._errorElements = errorElements;\n    for (const el of this._errorElements) {\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    }\n\n    this._assignErrorMessageElements();\n    this.toggleState('has-error', !!this._errorElements.length);\n    this._syncNegative();\n  }\n\n  private _assignErrorMessageElements(): void {\n    if (this._input) {\n      this._input.ariaDescribedByElements = appendAriaElements(\n        this._input.ariaDescribedByElements,\n        ...this._errorElements,\n      );\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  private _syncNegative(): void {\n    this.querySelectorAll?.(\n      'sbb-error,sbb-mini-button,sbb-mini-button-link,sbb-form-field-clear,sbb-datepicker-next-day,sbb-datepicker-previous-day,sbb-datepicker-toggle,sbb-select,sbb-autocomplete,sbb-autocomplete-grid,sbb-chip-group',\n    ).forEach((element) => element.toggleAttribute('negative', this.negative));\n  }\n\n  private _syncSize(): void {\n    this.querySelectorAll?.<SbbAutocompleteBaseElement | SbbSelectElement>(\n      'sbb-autocomplete,sbb-autocomplete-grid,sbb-select',\n    ).forEach((element) => (element.size = this.size === 's' ? 's' : 'm'));\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            ${this.hasUpdated && ['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  interface HTMLElementEventMap {\n    formfieldcontrol: SbbFormFieldControlEvent;\n  }\n}\n"],"names":["state"],"mappings":"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"}