@sbb-esta/lyne-elements-dev 5.0.0-next.3-dev.1779265349 → 5.0.0-next.3-dev.1779268556

package/development/select.component-BE7ZMrAc.js

@@ -0,0 +1,809 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, nothing, unsafeCSS } from "lit";
+import { property, state } from "lit/decorators.js";
+import { SbbDisabledMixin, SbbEscapableOverlayController, SbbFormAssociatedMixin, SbbLanguageController, SbbNegativeMixin, SbbOpenCloseBaseElement, SbbPropertyWatcherController, SbbReadonlyMixin, SbbRequiredMixin, SbbUpdateSchedulerMixin, forceType, getNextElementIndex, getOverride, handleDistinctChange, i18nSelectionRequired, isEventOnElement, isNextjs, isSafari, isZeroAnimationDuration, popoverResetStyles, scrollbarStyles, setOrRemoveAttribute, setOverlayPosition } from "./core.js";
+import { ResizeController } from "@lit-labs/observers/resize-controller.js";
+import { ref } from "lit/directives/ref.js";
+import { optionPanelStyles } from "./option.pure.js";
+import { MutationController } from "@lit-labs/observers/mutation-controller.js";
+import { until } from "lit/directives/until.js";
+//#region src/elements/select/select.scss?inline
+var select_default = ":host {\n  --sbb-select-placeholder-fallback-color: var(--sbb-color-metal);\n  --sbb-select-placeholder-fallback-color: light-dark(\n    var(--sbb-color-metal),\n    var(--sbb-color-smoke)\n  );\n  --sbb-options-panel-internal-z-index: var(\n    --sbb-select-z-index,\n    var(--sbb-overlay-default-z-index)\n  );\n  display: block;\n}\n\n:host([negative]) {\n  --sbb-select-placeholder-fallback-color: var(--sbb-color-5);\n}\n\n.sbb-select__trigger {\n  overflow: hidden;\n  white-space: nowrap;\n  text-overflow: ellipsis;\n  cursor: var(--sbb-cursor-default);\n  height: calc(1em * var(--sbb-typo-line-height-text));\n}\n:host(:not(:is(:state(has-display-value),[state--has-display-value]))) .sbb-select__trigger {\n  color: var(--sbb-select-placeholder-color, var(--sbb-select-placeholder-fallback-color));\n  -webkit-text-fill-color: var(--sbb-select-placeholder-color, var(--sbb-select-placeholder-fallback-color));\n}";
+//#endregion
+//#region src/elements/select/select.component.ts
+/**
+* On Safari, the aria role 'listbox' must be on the host element, or else VoiceOver won't work at all.
+* On the other hand, JAWS and NVDA need the role to be an "immediate parent" to the options, or else optgroups won't work.
+*/
+var ariaRoleOnHost = isSafari;
+var nextId = 0;
+/**
+* It displays a panel with selectable options.
+*
+* @slot - Use the unnamed slot to add options.
+* @cssprop [--sbb-select-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+* the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+* component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+* @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.
+* If the calculated remaining space is smaller, the value gets ignored.
+* @overrideType value - (T = string | string[]) | null
+*/
+var SbbSelectElement = (() => {
+	let _classSuper = SbbUpdateSchedulerMixin(SbbDisabledMixin(SbbNegativeMixin(SbbRequiredMixin(SbbReadonlyMixin(SbbFormAssociatedMixin(SbbOpenCloseBaseElement))))));
+	let _instanceExtraInitializers = [];
+	let _placeholder_decorators;
+	let _placeholder_initializers = [];
+	let _placeholder_extraInitializers = [];
+	let _multiple_decorators;
+	let _multiple_initializers = [];
+	let _multiple_extraInitializers = [];
+	let _compareWith_decorators;
+	let _compareWith_initializers = [];
+	let _compareWith_extraInitializers = [];
+	let _disabled_decorators;
+	let _disabled_initializers = [];
+	let _disabled_extraInitializers = [];
+	let _set_value_decorators;
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	let __displayValue_decorators;
+	let __displayValue_initializers = [];
+	let __displayValue_extraInitializers = [];
+	return class SbbSelectElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_placeholder_decorators = [forceType(), property()];
+			_multiple_decorators = [
+				forceType(),
+				handleDistinctChange((e, newValue) => e._onMultipleChanged(newValue)),
+				property({
+					reflect: true,
+					type: Boolean
+				})
+			];
+			_compareWith_decorators = [property({ attribute: false })];
+			_disabled_decorators = [
+				forceType(),
+				handleDistinctChange((e, newValue) => e._closeOnDisabledReadonlyChanged(newValue)),
+				property({
+					reflect: true,
+					type: Boolean
+				}),
+				getOverride((e, v) => v || e.isDisabledExternally())
+			];
+			_set_value_decorators = [property()];
+			_size_decorators = [property({ reflect: true })];
+			__displayValue_decorators = [state()];
+			__esDecorate(this, null, _placeholder_decorators, {
+				kind: "accessor",
+				name: "placeholder",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "placeholder" in obj,
+					get: (obj) => obj.placeholder,
+					set: (obj, value) => {
+						obj.placeholder = value;
+					}
+				},
+				metadata: _metadata
+			}, _placeholder_initializers, _placeholder_extraInitializers);
+			__esDecorate(this, null, _multiple_decorators, {
+				kind: "accessor",
+				name: "multiple",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "multiple" in obj,
+					get: (obj) => obj.multiple,
+					set: (obj, value) => {
+						obj.multiple = value;
+					}
+				},
+				metadata: _metadata
+			}, _multiple_initializers, _multiple_extraInitializers);
+			__esDecorate(this, null, _compareWith_decorators, {
+				kind: "accessor",
+				name: "compareWith",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "compareWith" in obj,
+					get: (obj) => obj.compareWith,
+					set: (obj, value) => {
+						obj.compareWith = value;
+					}
+				},
+				metadata: _metadata
+			}, _compareWith_initializers, _compareWith_extraInitializers);
+			__esDecorate(this, null, _disabled_decorators, {
+				kind: "accessor",
+				name: "disabled",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "disabled" in obj,
+					get: (obj) => obj.disabled,
+					set: (obj, value) => {
+						obj.disabled = value;
+					}
+				},
+				metadata: _metadata
+			}, _disabled_initializers, _disabled_extraInitializers);
+			__esDecorate(this, null, _set_value_decorators, {
+				kind: "setter",
+				name: "value",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "value" in obj,
+					set: (obj, value) => {
+						obj.value = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, 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(this, null, __displayValue_decorators, {
+				kind: "accessor",
+				name: "_displayValue",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_displayValue" in obj,
+					get: (obj) => obj._displayValue,
+					set: (obj, value) => {
+						obj._displayValue = value;
+					}
+				},
+				metadata: _metadata
+			}, __displayValue_initializers, __displayValue_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-select";
+		}
+		static {
+			this.role = ariaRoleOnHost ? "listbox" : null;
+		}
+		static {
+			this.styles = [
+				popoverResetStyles,
+				scrollbarStyles,
+				optionPanelStyles,
+				unsafeCSS(select_default)
+			];
+		}
+		static {
+			this.events = {
+				change: "change",
+				input: "input",
+				displayvaluechange: "displayvaluechange",
+				beforeopen: "beforeopen",
+				open: "open",
+				beforeclose: "beforeclose",
+				close: "close"
+			};
+		}
+		#placeholder_accessor_storage;
+		/** The placeholder used if no value has been selected. */
+		get placeholder() {
+			return this.#placeholder_accessor_storage;
+		}
+		set placeholder(value) {
+			this.#placeholder_accessor_storage = value;
+		}
+		#multiple_accessor_storage;
+		/** Whether the select allows for multiple selection. */
+		get multiple() {
+			return this.#multiple_accessor_storage;
+		}
+		set multiple(value) {
+			this.#multiple_accessor_storage = value;
+		}
+		#compareWith_accessor_storage;
+		/** Function used to compare option values. */
+		get compareWith() {
+			return this.#compareWith_accessor_storage;
+		}
+		set compareWith(value) {
+			this.#compareWith_accessor_storage = value;
+		}
+		#disabled_accessor_storage;
+		get disabled() {
+			return this.#disabled_accessor_storage;
+		}
+		set disabled(value) {
+			this.#disabled_accessor_storage = value;
+		}
+		/** Value of the form element. */
+		set value(value) {
+			this._value = value;
+			this._isValueManuallyAssigned = true;
+			this._updateOptionsFromValue();
+		}
+		get value() {
+			return this._value;
+		}
+		#size_accessor_storage;
+		/**
+		* Size variant, either s (lean theme default) or m (standard theme default).
+		* When placed inside an `<sbb-form-field>`, the size is inherited from the form field.
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		/**
+		* Form type of element.
+		* @default 'select-one / select-multiple'
+		*/
+		get type() {
+			return this.multiple ? "select-multiple" : "select-one";
+		}
+		#_displayValue_accessor_storage;
+		/** The value displayed by the component. */
+		get _displayValue() {
+			return this.#_displayValue_accessor_storage;
+		}
+		set _displayValue(value) {
+			this.#_displayValue_accessor_storage = value;
+		}
+		/**
+		* The 'combobox' input element
+		* @internal
+		*/
+		get inputElement() {
+			return this._triggerElement ?? null;
+		}
+		/** Returns all SbbOptionElements from this sbb-select instance. */
+		get options() {
+			const options = [];
+			this.querySelectorAll?.("sbb-option").forEach((option) => {
+				customElements.upgrade(option);
+				options.push(option);
+			});
+			return options;
+		}
+		constructor() {
+			super();
+			this.#placeholder_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _placeholder_initializers, ""));
+			this.#multiple_accessor_storage = (__runInitializers(this, _placeholder_extraInitializers), __runInitializers(this, _multiple_initializers, false));
+			this.#compareWith_accessor_storage = (__runInitializers(this, _multiple_extraInitializers), __runInitializers(this, _compareWith_initializers, (v1, v2) => v1 === v2));
+			this.#disabled_accessor_storage = (__runInitializers(this, _compareWith_extraInitializers), __runInitializers(this, _disabled_initializers, false));
+			this._value = (__runInitializers(this, _disabled_extraInitializers), null);
+			this.#size_accessor_storage = __runInitializers(this, _size_initializers, null);
+			this.#_displayValue_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, __displayValue_initializers, null));
+			this._resizeObserver = (__runInitializers(this, __displayValue_extraInitializers), new ResizeController(this, {
+				target: null,
+				skipInitial: true,
+				callback: (() => {
+					let timeoutId;
+					return () => {
+						clearTimeout(timeoutId);
+						timeoutId = setTimeout(() => {
+							if (this.state !== "closed") this._setOverlayPosition();
+						}, 10);
+					};
+				})()
+			}));
+			this._originElement = null;
+			this._triggerElement = null;
+			this._escapableOverlayController = new SbbEscapableOverlayController(this);
+			this._overlayId = `sbb-select-${++nextId}`;
+			this._activeItemIndex = -1;
+			this._searchString = "";
+			this._didLoad = false;
+			this._isPointerDownEventOnMenu = false;
+			this._languageController = new SbbLanguageController(this);
+			this._isValueManuallyAssigned = false;
+			this._pointerDownListener = (event) => {
+				this._isPointerDownEventOnMenu = isEventOnElement(this._overlay, event);
+			};
+			this._closeOnBackdropClick = (event) => {
+				if (!this._isPointerDownEventOnMenu && !isEventOnElement(this._overlay, event) && !isEventOnElement(this._originElement, event)) this.close();
+			};
+			this.addEventListener?.("optionselectionchange", (e) => this._onOptionChanged(e));
+			this.addEventListener?.("optionLabelChanged", (e) => this._onOptionLabelChanged(e));
+			/** Forces the sbb-select to update his value. */
+			this.addEventListener?.("ɵoptionvaluechange", () => this._updateValueOptionState());
+			this.addEventListener?.("ɵoptgroupslotchange", () => this._updateValueOptionState(), { capture: true });
+			this.addEventListener?.("click", (e) => {
+				const target = e.target;
+				if (target.localName === "sbb-option") {
+					if (!this.multiple && !target.disabled) {
+						this.close();
+						this.focus();
+					}
+				} else this._toggleOpening();
+			});
+			this.addController(new MutationController(this, {
+				config: { attributeFilter: [
+					"aria-labelledby",
+					"aria-label",
+					"aria-describedby"
+				] },
+				callback: () => this._syncAriaLabels()
+			}));
+			this.addController(new SbbPropertyWatcherController(this, () => this.closest("sbb-form-field"), { negative: (e) => {
+				this.negative = e.negative;
+				this._syncNegative();
+			} }));
+		}
+		_syncAriaLabels() {
+			if (!this._triggerElement || isServer) return;
+			setOrRemoveAttribute(this._triggerElement, "aria-labelledby", this.getAttribute("aria-labelledby"));
+			setOrRemoveAttribute(this._triggerElement, "aria-label", this.getAttribute("aria-label"));
+			setOrRemoveAttribute(this._triggerElement, "aria-describedby", this.getAttribute("aria-describedby"));
+			if (!this.getAttribute("aria-label") && !this.getAttribute("aria-labelledby") && this.internals.labels.length) this._triggerElement?.setAttribute("aria-label", Array.from(this.internals.labels, (label) => label.textContent).join(", "));
+		}
+		/** Opens the selection panel. */
+		open() {
+			if (this.state === "opening" || this.state === "opened" || !this._overlay || this.options.length === 0 || this.disabled || this.formDisabled || !this.dispatchBeforeOpenEvent()) return;
+			this.shadowRoot?.querySelector("[popover]")?.showPopover?.();
+			this.state = "opening";
+			this.internals.states.add("expanded");
+			this._setOverlayPosition();
+			this._escapableOverlayController.connect();
+			this._attachOpenPanelEvents();
+			if (this._isZeroAnimationDuration()) this._handleOpening();
+		}
+		/** Closes the selection panel. */
+		close() {
+			if (this.state === "closing" || this.state === "closed" || !this.dispatchBeforeCloseEvent()) return;
+			this.state = "closing";
+			this.internals.states.delete("expanded");
+			this._openPanelEventsController?.abort();
+			if (this._originElement) this._resizeObserver.unobserve(this._originElement);
+			if (this._isZeroAnimationDuration()) this._handleClosing();
+		}
+		_isZeroAnimationDuration() {
+			return isZeroAnimationDuration(this, "--sbb-options-panel-animation-duration");
+		}
+		/** Gets the current displayed value. */
+		getDisplayValue() {
+			return this._displayValue ?? "";
+		}
+		_selectableOptions() {
+			return this.options.filter((opt) => !opt.matches(":is(:state(disabled),[state--disabled])"));
+		}
+		/** Listens to option changes. */
+		_onOptionChanged(event) {
+			const target = event.target;
+			if (target.selected) this._onOptionSelected(target);
+			else this._onOptionDeselected(target);
+		}
+		/** Listens to option changes. */
+		_onOptionLabelChanged(event) {
+			const target = event.target;
+			const selected = this._getSelected();
+			if (!Array.isArray(selected) && target !== selected || Array.isArray(selected) && !selected.includes(target)) return;
+			this._updateDisplayValue();
+		}
+		_updateDisplayValue() {
+			const selected = this._getSelected();
+			if (Array.isArray(selected)) this._displayValue = selected.map((o) => o.textContent?.trim()).join(", ") || null;
+			else if (selected) this._displayValue = selected?.textContent?.trim() || null;
+			else this._displayValue = null;
+			this.toggleState("has-display-value", !!this._displayValue);
+			/** @internal */
+			this.dispatchEvent(new Event("displayvaluechange", {
+				bubbles: true,
+				composed: true
+			}));
+		}
+		/**
+		* The `value` property should be adapted when the `multiple` property changes:
+		*   - if it changes to true, the 'value' is set to an array;
+		*   - if it changes to false, the first available option is set as 'value' otherwise it's set to null.
+		*/
+		_onMultipleChanged(isChangingToMultiple) {
+			if (isChangingToMultiple) this._value = this._isValueManuallyAssigned || this.value != null ? [this.value] : [];
+			else if (Array.isArray(this.value)) this._value = this.value.length ? this.value[0] : null;
+			this._updateDisplayValue();
+		}
+		/**
+		* If the `disabled` or the `readonly` properties are set, and the panel is open, close it.
+		*/
+		_closeOnDisabledReadonlyChanged(newValue) {
+			if ((this.state === "opening" || this.state === "opened") && newValue) this.close();
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this._updateValueOptionState();
+			if (!isNextjs()) {
+				this.startUpdate();
+				this._setupSelect();
+			}
+		}
+		/** @internal */
+		focus() {
+			this._triggerElement?.focus();
+		}
+		/** @internal */
+		blur() {
+			this._triggerElement?.blur();
+		}
+		/**
+		* Removes element's first attribute whose qualified name is qualifiedName.
+		*
+		* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/removeAttribute)
+		* @internal We need to override this due to a hydration issue with Next.js.
+		*/
+		removeAttribute(qualifiedName) {
+			if (isNextjs() && qualifiedName === "defer-hydration" && !this._didLoad) this.updateComplete.then(() => this._setupSelect());
+			super.removeAttribute(qualifiedName);
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			if (ariaRoleOnHost) this.id ||= this._overlayId;
+			this._syncNegative();
+			this._syncAriaLabels();
+			if (this._didLoad) {
+				this._setupOrigin();
+				this._setupTrigger();
+			}
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (!name && this.hasUpdated) setTimeout(() => this._syncAriaLabels());
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("negative")) this._syncNegative();
+			if (changedProperties.has("readOnly")) this._closeOnDisabledReadonlyChanged(this.readOnly);
+		}
+		disconnectedCallback() {
+			if (this._triggerElement) this.prepend(this._triggerElement);
+			super.disconnectedCallback();
+			this._openPanelEventsController?.abort();
+		}
+		/**
+		* The reset value is the attribute value (the setup value), null otherwise.
+		* @internal
+		*/
+		formResetCallback() {
+			this.value = this.hasAttribute("value") ? this.getAttribute("value") : null;
+		}
+		/**
+		* @internal
+		*/
+		formStateRestoreCallback(state, _reason) {
+			try {
+				const { value, manuallyAssigned } = JSON.parse(state);
+				this._isValueManuallyAssigned = manuallyAssigned;
+				this._value = value;
+				this._updateOptionsFromValue();
+			} catch {
+				console.warn(`Failed to restore sbb-select with state ${state}`);
+			}
+		}
+		formState() {
+			return JSON.stringify({
+				value: this.value,
+				manuallyAssigned: this._isValueManuallyAssigned
+			});
+		}
+		_syncNegative() {
+			this.querySelectorAll?.("sbb-divider, sbb-option-hint").forEach((el) => el.negative = this.negative);
+		}
+		shouldValidate(name) {
+			return super.shouldValidate(name) || name === "value" || name === "required";
+		}
+		validate() {
+			super.validate();
+			const value = Array.isArray(this.value) ? this.value : this.value === null ? [] : [this.value];
+			if (this.required && (this.options.every((o) => value.every((v) => !this.compareWith(v, o.value))) || !this._isValueManuallyAssigned && this.value == null)) this.setValidityFlag("valueMissing", i18nSelectionRequired[this._languageController.current]);
+			else this.removeValidityFlag("valueMissing");
+		}
+		_setupSelect() {
+			this._setupOrigin();
+			this._setupTrigger();
+			this._didLoad = true;
+			this.completeUpdate();
+		}
+		/** Sets the originElement; if the component is used in a sbb-form-field uses it, otherwise uses the parentElement. */
+		_setupOrigin() {
+			const formField = this.closest?.("sbb-form-field");
+			if (this._originElement) this._resizeObserver.unobserve(this._originElement);
+			this._originElement = formField?.shadowRoot?.querySelector?.("#overlay-anchor") ?? this.parentElement;
+			if (this._originElement) {
+				this.toggleState("option-panel-origin-borderless", formField?.hasAttribute?.("borderless"));
+				if (this.isOpen) this._resizeObserver.observe(this._originElement);
+			}
+		}
+		/**
+		* To assess screen-readers problems caused by the interaction between aria patterns and shadow DOM,
+		* we are forced to move the 'combobox' trigger element to the light DOM
+		*/
+		_setupTrigger() {
+			if (this.parentElement && this._triggerElement) this.parentElement.insertBefore?.(this._triggerElement, this);
+		}
+		_setOverlayPosition() {
+			if (!this._originElement) return;
+			setOverlayPosition(this._overlay, this._originElement, this._overlay, this.shadowRoot.querySelector(".sbb-option-panel__overlay-container"), this);
+		}
+		_onAnimationEnd(event) {
+			if (event.animationName === "open" && this.state === "opening") this._handleOpening();
+			else if (event.animationName === "close" && this.state === "closing") this._handleClosing();
+		}
+		_handleOpening() {
+			this.state = "opened";
+			this._triggerElement?.setAttribute("aria-expanded", "true");
+			if (this._originElement) this._resizeObserver.observe(this._originElement);
+			this.dispatchOpenEvent();
+		}
+		_handleClosing() {
+			this.state = "closed";
+			this.shadowRoot?.querySelector("[popover]")?.hidePopover?.();
+			this._triggerElement?.setAttribute("aria-expanded", "false");
+			this._resetActiveElement();
+			this._overlay.scrollTop = 0;
+			this._escapableOverlayController.disconnect();
+			this.dispatchCloseEvent();
+		}
+		/** When an option is selected, updates the displayValue; it also closes the select if not `multiple`. */
+		_onOptionSelected(option) {
+			if (!this.multiple) this._value = option.value;
+			else if (!this.value) this._value = [option.value];
+			else if (Array.isArray(this.value) && !this.value.some((v) => this.compareWith(v, option.value))) this._value = [...this.value, option.value];
+			this._updateOptionsFromValue();
+			this._dispatchInputEvents();
+		}
+		/** When an option is unselected in `multiple`, removes it from value and updates displayValue. */
+		_onOptionDeselected(optionSelectionChange) {
+			if (this.multiple && Array.isArray(this.value)) {
+				this._value = this.value.filter((el) => !this.compareWith(el, optionSelectionChange.value));
+				this._updateOptionsFromValue();
+				this._dispatchInputEvents();
+			}
+		}
+		_dispatchInputEvents() {
+			/** The input event fires when the value has been changed as a direct result of a user action. */
+			this.dispatchEvent(new InputEvent("input", {
+				bubbles: true,
+				composed: true
+			}));
+			/**
+			* The change event is fired when the user modifies the element's value.
+			* Unlike the input event, the change event is not necessarily fired
+			* for each alteration to an element's value.
+			*/
+			this.dispatchEvent(new Event("change", { bubbles: true }));
+		}
+		_attachOpenPanelEvents() {
+			this._openPanelEventsController = new AbortController();
+			document.addEventListener("scroll", () => this._setOverlayPosition(), {
+				passive: true,
+				signal: this._openPanelEventsController.signal,
+				capture: true
+			});
+			window.addEventListener("resize", () => this._setOverlayPosition(), {
+				passive: true,
+				signal: this._openPanelEventsController.signal
+			});
+			window.addEventListener("pointerdown", (ev) => this._pointerDownListener(ev), { signal: this._openPanelEventsController.signal });
+			window.addEventListener("pointerup", (ev) => this._closeOnBackdropClick(ev), { signal: this._openPanelEventsController.signal });
+		}
+		_onKeyDown(event) {
+			if (this.readOnly) return;
+			if (this.state === "opening" || this.state === "opened") this._openedPanelKeyboardInteraction(event);
+			else if (this.state === "closed" || this.state === "closing") this._closedPanelKeyboardInteraction(event);
+		}
+		_closedPanelKeyboardInteraction(event) {
+			if (this._checkForLetterSelection(event)) return this._setNextActiveOptionByText(event);
+			switch (event.key) {
+				case "Enter":
+				case " ":
+				case "ArrowDown":
+				case "ArrowUp":
+					event.preventDefault();
+					this.open();
+					break;
+			}
+		}
+		_openedPanelKeyboardInteraction(event) {
+			if (this.readOnly) return;
+			if (this._checkForLetterSelection(event)) return this._setNextActiveOptionByText(event);
+			switch (event.key) {
+				case "Tab":
+					this.close();
+					break;
+				case "Enter":
+				case " ":
+					event.preventDefault();
+					this._selectByKeyboard();
+					break;
+				case "ArrowDown":
+				case "ArrowUp":
+					event.preventDefault();
+					this._setNextActiveOption(event);
+					break;
+				case "Home":
+				case "PageUp":
+					event.preventDefault();
+					this._setNextActiveOption(event, 0);
+					break;
+				case "End":
+				case "PageDown":
+					event.preventDefault();
+					this._setNextActiveOption(event, this._selectableOptions().length - 1);
+					break;
+			}
+		}
+		_checkForLetterSelection(event) {
+			return event.key === "Backspace" || event.key === "Clear" || event.key.length === 1 && event.key !== " " && !event.altKey && !event.ctrlKey && !event.metaKey;
+		}
+		_setNextActiveOptionByText(event) {
+			if (typeof this._searchTimeout === typeof setTimeout) clearTimeout(this._searchTimeout);
+			this._searchTimeout = setTimeout(() => this._searchString = "", 1e3);
+			this._searchString += event.key;
+			const indexForSlice = this._activeItemIndex + 1;
+			const selectableOptions = this._selectableOptions();
+			const filteredOptionsSorted = [...selectableOptions.slice(indexForSlice), ...selectableOptions.slice(0, indexForSlice)];
+			const match = filteredOptionsSorted.find((option) => option.textContent?.toLowerCase().indexOf(this._searchString.toLowerCase()) === 0);
+			if (match) this._setNextActiveOption(event, selectableOptions.indexOf(match));
+			else if (this._searchString.length > 1 && new RegExp(`^${this._searchString.charAt(0)}*$`).test(this._searchString)) {
+				const firstMatch = filteredOptionsSorted.find((option) => option.textContent?.toLowerCase().indexOf(this._searchString[0].toLowerCase()) === 0);
+				if (firstMatch) this._setNextActiveOption(event, selectableOptions.indexOf(firstMatch));
+			} else {
+				clearTimeout(this._searchTimeout);
+				this._searchString = "";
+			}
+		}
+		_selectByKeyboard() {
+			const activeOption = this._selectableOptions()[this._activeItemIndex];
+			if (this.multiple) activeOption?.["selectViaUserInteraction"](!activeOption.selected);
+			else this.close();
+		}
+		_setNextActiveOption(event, index) {
+			const filteredOptions = this._selectableOptions();
+			if (filteredOptions.length === 0) return;
+			const nextIndex = index ?? getNextElementIndex(event, this._activeItemIndex, filteredOptions.length);
+			const nextOption = filteredOptions[nextIndex];
+			const activeOption = filteredOptions[this._activeItemIndex];
+			this._setActiveElement(nextOption, activeOption);
+			if (!this.multiple) this._setSelectedElement(nextOption, activeOption);
+			else if (event?.shiftKey) nextOption["selectViaUserInteraction"](!nextOption.selected);
+			this._activeItemIndex = nextIndex;
+		}
+		_setActiveElement(nextActiveOption, lastActiveOption = null, setActiveDescendant = true) {
+			nextActiveOption.setActive(true);
+			nextActiveOption.scrollIntoView({ block: "nearest" });
+			if (setActiveDescendant) this._triggerElement?.setAttribute("aria-activedescendant", nextActiveOption.id);
+			if (lastActiveOption && !this.compareWith(lastActiveOption.value, nextActiveOption.value)) lastActiveOption.setActive(false);
+		}
+		_setSelectedElement(nextActiveOption, lastActiveOption) {
+			nextActiveOption["selectViaUserInteraction"](true);
+			if (lastActiveOption && !this.compareWith(lastActiveOption.value, nextActiveOption.value)) lastActiveOption["selectViaUserInteraction"](false);
+		}
+		_resetActiveElement() {
+			const activeElement = this._selectableOptions()[this._activeItemIndex];
+			if (activeElement) activeElement.setActive(false);
+			this._activeItemIndex = -1;
+			this._triggerElement?.removeAttribute("aria-activedescendant");
+		}
+		_updateOptionsFromValue() {
+			const value = Array.isArray(this.value) ? this.value : [this.value];
+			const displayValues = [];
+			for (const option of this.options) {
+				option.selected = value.some((v) => this.compareWith(v, option.value));
+				if (option.selected) displayValues.push(option);
+			}
+			this._updateDisplayValue();
+			if (!Array.isArray(this.value)) {
+				const value = this.value;
+				this._activeItemIndex = this._selectableOptions().findIndex((option) => this.compareWith(option.value, value));
+			}
+		}
+		_updateValueFromOptions() {
+			const selected = this._getSelected();
+			if (Array.isArray(selected)) {
+				if (selected && selected.length > 0) {
+					const value = [];
+					for (const option of selected) value.push(option.value);
+					this._value = value;
+				}
+			} else if (selected) {
+				this._activeItemIndex = this._selectableOptions().findIndex((option) => option === selected);
+				this._value = selected.value;
+			}
+			this._updateDisplayValue();
+		}
+		_updateValueOptionState() {
+			if (this._isValueManuallyAssigned) this._updateOptionsFromValue();
+			else this._updateValueFromOptions();
+		}
+		_getSelected() {
+			if (this.multiple) return this.options.filter((option) => option.selected);
+			else return this.options.find((option) => option.selected) ?? null;
+		}
+		_toggleOpening() {
+			if (this.disabled || this.formDisabled || this.readOnly) return;
+			this._triggerElement?.focus();
+			switch (this.state) {
+				case "opening":
+				case "opened":
+					this.close();
+					break;
+				case "closing":
+				case "closed":
+					this.open();
+					break;
+				default: break;
+			}
+		}
+		_spreadDeferredDisplayValue(placeholder) {
+			return [this._deferredDisplayValue(placeholder), placeholder];
+		}
+		async _deferredDisplayValue(placeholder) {
+			if (this.hydrationRequired) await this.hydrationComplete;
+			return this._displayValue ? html`${this._displayValue}` : placeholder;
+		}
+		render() {
+			return html`
+      <!-- This element is visually hidden and will be appended to the light DOM to allow screen
+      readers to work properly -->
+      <div
+        class="sbb-screen-reader-only sbb-select-trigger"
+        tabindex=${this.disabled || this.formDisabled ? nothing : "0"}
+        role="combobox"
+        aria-haspopup="listbox"
+        aria-expanded="false"
+        aria-required=${this.required.toString()}
+        aria-controls=${this._overlayId}
+        aria-owns=${this._overlayId}
+        @keydown=${this._onKeyDown}
+        @click=${this._toggleOpening}
+        ${ref((ref) => this._triggerElement = ref)}
+      >
+        ${until(...this._spreadDeferredDisplayValue(html`${this.placeholder}`))}
+      </div>
+
+      <!-- Visually display the value -->
+      <div class="sbb-select__trigger" aria-hidden="true">
+        ${until(...this._spreadDeferredDisplayValue(html`${this.placeholder}`))}
+      </div>
+
+      <div class="sbb-option-panel__overlay-container sbb-popover-reset" popover="manual">
+        <div
+          class="sbb-option-panel__overlay ${this.negative ? "sbb-scrollbar-negative" : "sbb-scrollbar"}"
+          id=${!ariaRoleOnHost ? this._overlayId : nothing}
+          role=${!ariaRoleOnHost ? "listbox" : nothing}
+          ?aria-multiselectable=${this.multiple}
+          tabindex="-1"
+          @animationend=${this._onAnimationEnd}
+          ${ref((dialogRef) => this._overlay = dialogRef)}
+        >
+          <slot @slotchange=${this._updateValueOptionState}></slot>
+        </div>
+      </div>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbSelectElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"select.component-BE7ZMrAc.js","names":[],"sources":["../../../src/elements/select/select.scss?inline","../../../src/elements/select/select.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  --sbb-select-placeholder-fallback-color: light-dark(\n    var(--sbb-color-metal),\n    var(--sbb-color-smoke)\n  );\n  --sbb-options-panel-internal-z-index: var(\n    --sbb-select-z-index,\n    var(--sbb-overlay-default-z-index)\n  );\n\n  display: block;\n}\n\n:host([negative]) {\n  --sbb-select-placeholder-fallback-color: var(--sbb-color-5);\n}\n\n.sbb-select__trigger {\n  @include sbb.ellipsis;\n\n  cursor: var(--sbb-cursor-default);\n  height: calc(1em * var(--sbb-typo-line-height-text));\n\n  :host(:not(:state(has-display-value))) & {\n    color: var(--sbb-select-placeholder-color, var(--sbb-select-placeholder-fallback-color));\n\n    // Note: when the sbb-select is used within a sbb-form-field, some style are applied from it\n    // (see selector `.sbb-form-field__input ::slotted(:where(input, select, sbb-select))` in the sbb-form-field.scss);\n    // so, next line is mandatory because we need to override the rule from the parent.\n    -webkit-text-fill-color: var(\n      --sbb-select-placeholder-color,\n      var(--sbb-select-placeholder-fallback-color)\n    );\n  }\n}\n","import { MutationController } from '@lit-labs/observers/mutation-controller.js';\nimport { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  isServer,\n  nothing,\n  type PropertyDeclaration,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property, state } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\nimport { until } from 'lit/directives/until.js';\n\nimport {\n  forceType,\n  type FormRestoreReason,\n  type FormRestoreState,\n  getNextElementIndex,\n  getOverride,\n  handleDistinctChange,\n  i18nSelectionRequired,\n  isEventOnElement,\n  isNextjs,\n  isSafari,\n  isZeroAnimationDuration,\n  popoverResetStyles,\n  SbbDisabledMixin,\n  SbbEscapableOverlayController,\n  SbbFormAssociatedMixin,\n  SbbLanguageController,\n  SbbNegativeMixin,\n  SbbOpenCloseBaseElement,\n  SbbPropertyWatcherController,\n  SbbReadonlyMixin,\n  SbbRequiredMixin,\n  SbbUpdateSchedulerMixin,\n  scrollbarStyles,\n  setOrRemoveAttribute,\n  setOverlayPosition,\n} from '../core.ts';\nimport type { SbbDividerElement } from '../divider.pure.ts';\nimport type { SbbFormFieldElement } from '../form-field/form-field/form-field.component.ts';\nimport {\n  optionPanelStyles,\n  type SbbOptionElement,\n  type SbbOptionHintElement,\n} from '../option.pure.ts';\n\nimport style from './select.scss?inline';\n\n/**\n * On Safari, the aria role 'listbox' must be on the host element, or else VoiceOver won't work at all.\n * On the other hand, JAWS and NVDA need the role to be an \"immediate parent\" to the options, or else optgroups won't work.\n */\nconst ariaRoleOnHost = isSafari;\n\nlet nextId = 0;\n\n/**\n * It displays a panel with selectable options.\n *\n * @slot - Use the unnamed slot to add options.\n * @cssprop [--sbb-select-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n * @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.\n * If the calculated remaining space is smaller, the value gets ignored.\n * @overrideType value - (T = string | string[]) | null\n */\nexport class SbbSelectElement<T = string> extends SbbUpdateSchedulerMixin(\n  SbbDisabledMixin(\n    SbbNegativeMixin(\n      SbbRequiredMixin(\n        SbbReadonlyMixin(\n          SbbFormAssociatedMixin<typeof SbbOpenCloseBaseElement>(SbbOpenCloseBaseElement),\n        ),\n      ),\n    ),\n  ),\n) {\n  public static override readonly elementName: string = 'sbb-select';\n  public static override readonly role = ariaRoleOnHost ? 'listbox' : null;\n  public static override styles: CSSResultGroup = [\n    popoverResetStyles,\n    scrollbarStyles,\n    optionPanelStyles,\n    unsafeCSS(style),\n  ];\n\n  // TODO: fix using ...super.events requires: https://github.com/sbb-design-systems/lyne-components/issues/2600\n  public static override readonly events = {\n    change: 'change',\n    input: 'input',\n    displayvaluechange: 'displayvaluechange',\n    beforeopen: 'beforeopen',\n    open: 'open',\n    beforeclose: 'beforeclose',\n    close: 'close',\n  } as const;\n\n  /** The placeholder used if no value has been selected. */\n  @forceType()\n  @property()\n  public accessor placeholder: string = '';\n\n  /** Whether the select allows for multiple selection. */\n  @forceType()\n  @handleDistinctChange((e: SbbSelectElement<T>, newValue: boolean) =>\n    e._onMultipleChanged(newValue),\n  )\n  @property({ reflect: true, type: Boolean })\n  public accessor multiple: boolean = false;\n\n  /** Function used to compare option values. */\n  @property({ attribute: false })\n  public accessor compareWith: (v1: T | null, v2: T | null) => boolean = (v1, v2) => v1 === v2;\n\n  @forceType()\n  @handleDistinctChange((e: SbbSelectElement<T>, newValue: boolean) =>\n    e._closeOnDisabledReadonlyChanged(newValue),\n  )\n  @property({ reflect: true, type: Boolean })\n  @getOverride((e: SbbSelectElement<T>, v: boolean): boolean => v || e.isDisabledExternally())\n  public override accessor disabled: boolean = false;\n\n  /** Value of the form element. */\n  @property()\n  public set value(value: T[] | T) {\n    this._value = value;\n    this._isValueManuallyAssigned = true;\n    this._updateOptionsFromValue();\n  }\n  public get value(): T[] | T | null {\n    return this._value;\n  }\n  private _value: T | T[] | null = null;\n\n  /**\n   * Size variant, either s (lean theme default) or m (standard theme default).\n   * When placed inside an `<sbb-form-field>`, the size is inherited from the form field.\n   */\n  @property({ reflect: true }) public accessor size: 's' | 'm' | null = null;\n\n  /**\n   * Form type of element.\n   * @default 'select-one / select-multiple'\n   */\n  public override get type(): string {\n    return this.multiple ? 'select-multiple' : 'select-one';\n  }\n\n  /** The value displayed by the component. */\n  @state() private accessor _displayValue: string | null = null;\n\n  private _resizeObserver = new ResizeController(this, {\n    target: null,\n    skipInitial: true,\n    // This is an IIFE, because we need to keep track of the timeout state\n    // for debouncing the resize callbacks.\n    callback: (() => {\n      let timeoutId: ReturnType<typeof setTimeout>;\n      return () => {\n        clearTimeout(timeoutId);\n        timeoutId = setTimeout(() => {\n          if (this.state !== 'closed') {\n            this._setOverlayPosition();\n          }\n        }, 10);\n      };\n    })(),\n  });\n\n  private _overlay!: HTMLElement;\n  private _originElement: HTMLElement | null = null;\n  private _triggerElement: HTMLElement | null = null;\n  private _openPanelEventsController?: AbortController;\n  private _escapableOverlayController = new SbbEscapableOverlayController(this);\n  private _overlayId = `sbb-select-${++nextId}`;\n  private _activeItemIndex = -1;\n  private _searchTimeout?: ReturnType<typeof setTimeout>;\n  private _searchString = '';\n  private _didLoad = false;\n  private _isPointerDownEventOnMenu: boolean = false;\n  private _languageController = new SbbLanguageController(this);\n  private _isValueManuallyAssigned = false;\n\n  /**\n   * The 'combobox' input element\n   * @internal\n   */\n  public get inputElement(): HTMLElement | null {\n    return this._triggerElement ?? null;\n  }\n\n  /** Returns all SbbOptionElements from this sbb-select instance. */\n  public get options(): SbbOptionElement<T>[] {\n    const options: SbbOptionElement<T>[] = [];\n    this.querySelectorAll?.<SbbOptionElement<T>>('sbb-option').forEach((option) => {\n      customElements.upgrade(option);\n      options.push(option);\n    });\n    return options;\n  }\n\n  public constructor() {\n    super();\n    this.addEventListener?.('optionselectionchange', (e: Event) => this._onOptionChanged(e));\n    this.addEventListener?.('optionLabelChanged', (e: Event) => this._onOptionLabelChanged(e));\n    /** Forces the sbb-select to update his value. */\n    this.addEventListener?.('ɵoptionvaluechange', () => this._updateValueOptionState());\n    this.addEventListener?.('ɵoptgroupslotchange', () => this._updateValueOptionState(), {\n      capture: true,\n    });\n    this.addEventListener?.('click', (e: MouseEvent) => {\n      const target = e.target as SbbSelectElement<T> | SbbOptionElement<T>;\n      if (target.localName === 'sbb-option') {\n        // Option click\n        if (!this.multiple && !target.disabled) {\n          this.close();\n          this.focus();\n        }\n      } else {\n        this._toggleOpening();\n      }\n    });\n\n    this.addController(\n      new MutationController(this, {\n        config: { attributeFilter: ['aria-labelledby', 'aria-label', 'aria-describedby'] },\n        callback: () => this._syncAriaLabels(),\n      }),\n    );\n\n    this.addController(\n      new SbbPropertyWatcherController(this, () => this.closest('sbb-form-field'), {\n        negative: (e) => {\n          this.negative = e.negative;\n          this._syncNegative();\n        },\n      }),\n    );\n  }\n\n  private _syncAriaLabels(): void {\n    if (!this._triggerElement || isServer) {\n      return;\n    }\n\n    setOrRemoveAttribute(\n      this._triggerElement,\n      'aria-labelledby',\n      this.getAttribute('aria-labelledby'),\n    );\n    setOrRemoveAttribute(this._triggerElement, 'aria-label', this.getAttribute('aria-label'));\n    setOrRemoveAttribute(\n      this._triggerElement,\n      'aria-describedby',\n      this.getAttribute('aria-describedby'),\n    );\n\n    // Using the associated labels is only a fallback.\n    // The drawback is, that it doesn't get updated automatically when the list of label changes.\n    if (\n      !this.getAttribute('aria-label') &&\n      !this.getAttribute('aria-labelledby') &&\n      this.internals.labels.length\n    ) {\n      this._triggerElement?.setAttribute(\n        'aria-label',\n        Array.from(this.internals.labels, (label) => label.textContent).join(', '),\n      );\n    }\n  }\n\n  /** Opens the selection panel. */\n  public open(): void {\n    if (\n      this.state === 'opening' ||\n      this.state === 'opened' ||\n      !this._overlay ||\n      this.options.length === 0 ||\n      this.disabled ||\n      this.formDisabled ||\n      !this.dispatchBeforeOpenEvent()\n    ) {\n      return;\n    }\n\n    this.shadowRoot?.querySelector<HTMLDivElement>('[popover]')?.showPopover?.();\n    this.state = 'opening';\n    this.internals.states.add('expanded');\n    this._setOverlayPosition();\n    this._escapableOverlayController.connect();\n    this._attachOpenPanelEvents();\n\n    // If the animation duration is zero, the animationend event is not always fired reliably.\n    // In this case we directly set the `opened` state.\n    if (this._isZeroAnimationDuration()) {\n      this._handleOpening();\n    }\n  }\n\n  /** Closes the selection panel. */\n  public close(): void {\n    if (this.state === 'closing' || this.state === 'closed' || !this.dispatchBeforeCloseEvent()) {\n      return;\n    }\n\n    this.state = 'closing';\n    this.internals.states.delete('expanded');\n    this._openPanelEventsController?.abort();\n    if (this._originElement) {\n      this._resizeObserver.unobserve(this._originElement);\n    }\n\n    // If the animation duration is zero, the animationend event is not always fired reliably.\n    // In this case we directly set the `closed` state.\n    if (this._isZeroAnimationDuration()) {\n      this._handleClosing();\n    }\n  }\n\n  private _isZeroAnimationDuration(): boolean {\n    return isZeroAnimationDuration(this, '--sbb-options-panel-animation-duration');\n  }\n\n  /** Gets the current displayed value. */\n  public getDisplayValue(): string {\n    return this._displayValue ?? '';\n  }\n\n  private _selectableOptions(): SbbOptionElement<T>[] {\n    return this.options.filter((opt) => !opt.matches(':state(disabled)'));\n  }\n\n  /** Listens to option changes. */\n  private _onOptionChanged(event: Event): void {\n    const target = event.target as SbbOptionElement<T>;\n    if (target.selected) {\n      this._onOptionSelected(target);\n    } else {\n      this._onOptionDeselected(target);\n    }\n  }\n\n  /** Listens to option changes. */\n  private _onOptionLabelChanged(event: Event): void {\n    const target = event.target as SbbOptionElement<T>;\n    const selected = this._getSelected();\n\n    if (\n      (!Array.isArray(selected) && target !== selected) ||\n      (Array.isArray(selected) && !selected.includes(target))\n    ) {\n      return;\n    }\n\n    this._updateDisplayValue();\n  }\n\n  private _updateDisplayValue(): void {\n    const selected = this._getSelected();\n    if (Array.isArray(selected)) {\n      this._displayValue = selected.map((o) => o.textContent?.trim()).join(', ') || null;\n    } else if (selected) {\n      this._displayValue = selected?.textContent?.trim() || null;\n    } else {\n      this._displayValue = null;\n    }\n\n    this.toggleState('has-display-value', !!this._displayValue);\n\n    /** @internal */\n    this.dispatchEvent(new Event('displayvaluechange', { bubbles: true, composed: true }));\n  }\n\n  /**\n   * The `value` property should be adapted when the `multiple` property changes:\n   *   - if it changes to true, the 'value' is set to an array;\n   *   - if it changes to false, the first available option is set as 'value' otherwise it's set to null.\n   */\n  private _onMultipleChanged(isChangingToMultiple: boolean): void {\n    if (isChangingToMultiple) {\n      this._value = this._isValueManuallyAssigned || this.value != null ? [this.value as T] : [];\n    } else if (Array.isArray(this.value)) {\n      this._value = this.value.length ? this.value[0] : null;\n    }\n    this._updateDisplayValue();\n  }\n\n  /**\n   * If the `disabled` or the `readonly` properties are set, and the panel is open, close it.\n   */\n  private _closeOnDisabledReadonlyChanged(newValue: boolean): void {\n    if ((this.state === 'opening' || this.state === 'opened') && newValue) {\n      this.close();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._updateValueOptionState();\n\n    // Wait for ssr hydration\n    if (!isNextjs()) {\n      this.startUpdate();\n      this._setupSelect();\n    }\n  }\n\n  /** @internal */\n  public override focus(): void {\n    // Forward focus to the trigger element.\n    this._triggerElement?.focus();\n  }\n\n  /** @internal */\n  public override blur(): void {\n    // Forward blur to the trigger element.\n    this._triggerElement?.blur();\n  }\n\n  /**\n   * Removes element's first attribute whose qualified name is qualifiedName.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/removeAttribute)\n   * @internal We need to override this due to a hydration issue with Next.js.\n   */\n  public override removeAttribute(qualifiedName: string): void {\n    // In Next.js the hydration needs to finish before we can manipulate the light DOM.\n    // @lit/react calls removeAttribute('defer-hydration') in a useLayoutEffect,\n    // which is done after hydration is finished. Due to this we intercept this call\n    // in overriding removeAttribute to finish initialization of the sbb-select.\n    // https://github.com/lit/lit/blob/main/packages/react/src/create-component.ts#L293-L296\n    // We also need to wait for update complete in order to be sure that the shadow DOM has been rendered.\n    if (isNextjs() && qualifiedName === 'defer-hydration' && !this._didLoad) {\n      this.updateComplete.then(() => this._setupSelect());\n    }\n    super.removeAttribute(qualifiedName);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    if (ariaRoleOnHost) {\n      this.id ||= this._overlayId;\n    }\n\n    this._syncNegative();\n    this._syncAriaLabels();\n\n    if (this._didLoad) {\n      this._setupOrigin();\n      this._setupTrigger();\n    }\n  }\n\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n  ): void {\n    super.requestUpdate(name, oldValue, options);\n    if (!name && this.hasUpdated) {\n      setTimeout(() => this._syncAriaLabels());\n    }\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('readOnly')) {\n      this._closeOnDisabledReadonlyChanged(this.readOnly);\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    // Take back the trigger element previously moved to the light DOM.\n    // Due to timing issues, this needs to be done before calling super.disconnectedCallback().\n    if (this._triggerElement) {\n      this.prepend(this._triggerElement);\n    }\n    super.disconnectedCallback();\n    this._openPanelEventsController?.abort();\n  }\n\n  /**\n   * The reset value is the attribute value (the setup value), null otherwise.\n   * @internal\n   */\n  public formResetCallback(): void {\n    this.value = (this.hasAttribute('value') ? this.getAttribute('value') : null) as T;\n  }\n\n  /**\n   * @internal\n   */\n  public formStateRestoreCallback(\n    state: FormRestoreState | null,\n    _reason: FormRestoreReason,\n  ): void {\n    try {\n      const { value, manuallyAssigned } = JSON.parse(state as string) as {\n        value: T | T[];\n        manuallyAssigned: boolean;\n      };\n\n      this._isValueManuallyAssigned = manuallyAssigned;\n      this._value = value;\n      this._updateOptionsFromValue();\n    } catch {\n      console.warn(`Failed to restore sbb-select with state ${state}`);\n    }\n  }\n\n  protected override formState(): FormRestoreState {\n    return JSON.stringify({ value: this.value, manuallyAssigned: this._isValueManuallyAssigned });\n  }\n\n  private _syncNegative(): void {\n    this.querySelectorAll?.<SbbDividerElement | SbbOptionHintElement>(\n      'sbb-divider, sbb-option-hint',\n    ).forEach((el) => (el.negative = this.negative));\n  }\n\n  protected override shouldValidate(name: PropertyKey | undefined): boolean {\n    return super.shouldValidate(name) || name === 'value' || name === 'required';\n  }\n\n  protected override validate(): void {\n    super.validate();\n\n    const value: T[] = Array.isArray(this.value)\n      ? this.value\n      : this.value === null\n        ? []\n        : [this.value];\n\n    if (\n      this.required &&\n      (this.options.every((o) => value.every((v) => !this.compareWith(v, o.value))) ||\n        (!this._isValueManuallyAssigned && this.value == null))\n    ) {\n      this.setValidityFlag('valueMissing', i18nSelectionRequired[this._languageController.current]);\n    } else {\n      this.removeValidityFlag('valueMissing');\n    }\n  }\n\n  private _setupSelect(): void {\n    this._setupOrigin();\n    this._setupTrigger();\n    this._didLoad = true;\n    this.completeUpdate();\n  }\n\n  /** Sets the originElement; if the component is used in a sbb-form-field uses it, otherwise uses the parentElement. */\n  private _setupOrigin(): void {\n    const formField = this.closest?.<SbbFormFieldElement>('sbb-form-field');\n    if (this._originElement) {\n      this._resizeObserver.unobserve(this._originElement);\n    }\n    this._originElement =\n      formField?.shadowRoot?.querySelector?.('#overlay-anchor') ?? this.parentElement!;\n    if (this._originElement) {\n      this.toggleState('option-panel-origin-borderless', formField?.hasAttribute?.('borderless'));\n\n      if (this.isOpen) {\n        this._resizeObserver.observe(this._originElement);\n      }\n    }\n  }\n\n  /**\n   * To assess screen-readers problems caused by the interaction between aria patterns and shadow DOM,\n   * we are forced to move the 'combobox' trigger element to the light DOM\n   */\n  private _setupTrigger(): void {\n    // Move the trigger before the sbb-select\n    if (this.parentElement && this._triggerElement) {\n      this.parentElement.insertBefore?.(this._triggerElement, this);\n    }\n  }\n\n  private _setOverlayPosition(): void {\n    if (!this._originElement) {\n      return;\n    }\n    setOverlayPosition(\n      this._overlay,\n      this._originElement,\n      this._overlay,\n      this.shadowRoot!.querySelector('.sbb-option-panel__overlay-container')!,\n      this,\n    );\n  }\n\n  // In rare cases it can be that the animationEnd event is triggered twice.\n  // To avoid entering a corrupt state, exit when state is not expected.\n  private _onAnimationEnd(event: AnimationEvent): void {\n    if (event.animationName === 'open' && this.state === 'opening') {\n      this._handleOpening();\n    } else if (event.animationName === 'close' && this.state === 'closing') {\n      this._handleClosing();\n    }\n  }\n\n  private _handleOpening(): void {\n    this.state = 'opened';\n    this._triggerElement?.setAttribute('aria-expanded', 'true');\n    if (this._originElement) {\n      this._resizeObserver.observe(this._originElement);\n    }\n    this.dispatchOpenEvent();\n  }\n\n  private _handleClosing(): void {\n    this.state = 'closed';\n    this.shadowRoot?.querySelector<HTMLDivElement>('[popover]')?.hidePopover?.();\n    this._triggerElement?.setAttribute('aria-expanded', 'false');\n    this._resetActiveElement();\n    this._overlay.scrollTop = 0;\n    this._escapableOverlayController.disconnect();\n    this.dispatchCloseEvent();\n  }\n\n  /** When an option is selected, updates the displayValue; it also closes the select if not `multiple`. */\n  private _onOptionSelected(option: SbbOptionElement<T>): void {\n    if (!this.multiple) {\n      this._value = option.value;\n    } else if (!this.value) {\n      this._value = [option.value!];\n    } else if (\n      Array.isArray(this.value) &&\n      !this.value.some((v) => this.compareWith(v, option.value!))\n    ) {\n      this._value = [...this.value, option.value!];\n    }\n\n    this._updateOptionsFromValue();\n    this._dispatchInputEvents();\n  }\n\n  /** When an option is unselected in `multiple`, removes it from value and updates displayValue. */\n  private _onOptionDeselected(optionSelectionChange: SbbOptionElement<T>): void {\n    if (this.multiple && Array.isArray(this.value)) {\n      this._value = this.value.filter((el) => !this.compareWith(el, optionSelectionChange.value));\n      this._updateOptionsFromValue();\n      this._dispatchInputEvents();\n    }\n  }\n\n  private _dispatchInputEvents(): void {\n    /** The input event fires when the value has been changed as a direct result of a user action. */\n    this.dispatchEvent(\n      new InputEvent('input', {\n        bubbles: true,\n        composed: true,\n      }),\n    );\n\n    /**\n     * The change event is fired when the user modifies the element's value.\n     * Unlike the input event, the change event is not necessarily fired\n     * for each alteration to an element's value.\n     */\n    this.dispatchEvent(new Event('change', { bubbles: true }));\n  }\n\n  private _attachOpenPanelEvents(): void {\n    this._openPanelEventsController = new AbortController();\n\n    // Recalculate the overlay position on scroll and window resize\n    document.addEventListener('scroll', () => this._setOverlayPosition(), {\n      passive: true,\n      signal: this._openPanelEventsController.signal,\n      // Without capture, other scroll contexts would not bubble to this event listener.\n      // Capture allows us to react to all scroll contexts in this DOM.\n      capture: true,\n    });\n    window.addEventListener('resize', () => this._setOverlayPosition(), {\n      passive: true,\n      signal: this._openPanelEventsController.signal,\n    });\n\n    // Close menu on backdrop click\n    window.addEventListener('pointerdown', (ev) => this._pointerDownListener(ev), {\n      signal: this._openPanelEventsController.signal,\n    });\n    window.addEventListener('pointerup', (ev) => this._closeOnBackdropClick(ev), {\n      signal: this._openPanelEventsController.signal,\n    });\n  }\n\n  private _onKeyDown(event: KeyboardEvent): void {\n    if (this.readOnly) {\n      return;\n    }\n\n    if (this.state === 'opening' || this.state === 'opened') {\n      this._openedPanelKeyboardInteraction(event);\n    } else if (this.state === 'closed' || this.state === 'closing') {\n      this._closedPanelKeyboardInteraction(event);\n    }\n  }\n\n  private _closedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (this._checkForLetterSelection(event)) {\n      return this._setNextActiveOptionByText(event);\n    }\n\n    switch (event.key) {\n      case 'Enter':\n      case ' ':\n      case 'ArrowDown':\n      case 'ArrowUp':\n        event.preventDefault();\n        this.open();\n        break;\n    }\n  }\n\n  private _openedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (this.readOnly) {\n      return;\n    }\n\n    if (this._checkForLetterSelection(event)) {\n      return this._setNextActiveOptionByText(event);\n    }\n\n    switch (event.key) {\n      case 'Tab':\n        this.close();\n        break;\n\n      case 'Enter':\n      case ' ':\n        event.preventDefault();\n        this._selectByKeyboard();\n        break;\n\n      case 'ArrowDown':\n      case 'ArrowUp':\n        event.preventDefault();\n        this._setNextActiveOption(event);\n        break;\n\n      case 'Home':\n      case 'PageUp':\n        event.preventDefault();\n        this._setNextActiveOption(event, 0);\n        break;\n\n      case 'End':\n      case 'PageDown':\n        event.preventDefault();\n        this._setNextActiveOption(event, this._selectableOptions().length - 1);\n        break;\n    }\n  }\n\n  private _checkForLetterSelection(event: KeyboardEvent): boolean {\n    return (\n      event.key === 'Backspace' ||\n      event.key === 'Clear' ||\n      (event.key.length === 1 &&\n        event.key !== ' ' &&\n        !event.altKey &&\n        !event.ctrlKey &&\n        !event.metaKey)\n    );\n  }\n\n  private _setNextActiveOptionByText(event: KeyboardEvent): void {\n    // Set timeout and the string to search.\n    if (typeof this._searchTimeout === typeof setTimeout) {\n      clearTimeout(this._searchTimeout);\n    }\n    this._searchTimeout = setTimeout(() => (this._searchString = ''), 1000);\n    this._searchString += event.key;\n\n    // Reorder the _filteredOption array to have the last selected element at the bottom.\n    const indexForSlice: number = this._activeItemIndex + 1;\n    const selectableOptions = this._selectableOptions();\n    const filteredOptionsSorted = [\n      ...selectableOptions.slice(indexForSlice),\n      ...selectableOptions.slice(0, indexForSlice),\n    ];\n\n    const match = filteredOptionsSorted.find(\n      (option) => option.textContent?.toLowerCase().indexOf(this._searchString.toLowerCase()) === 0,\n    );\n    if (match) {\n      // If an exact match has been found, go to that option.\n      this._setNextActiveOption(event, selectableOptions.indexOf(match));\n    } else if (\n      this._searchString.length > 1 &&\n      new RegExp(`^${this._searchString.charAt(0)}*$`).test(this._searchString)\n    ) {\n      // If no exact match has been found but the string to search is made by the same repeated letter,\n      // go to the first element, if exists, that matches the letter.\n      const firstMatch = filteredOptionsSorted.find(\n        (option) =>\n          option.textContent?.toLowerCase().indexOf(this._searchString[0].toLowerCase()) === 0,\n      );\n      if (firstMatch) {\n        this._setNextActiveOption(event, selectableOptions.indexOf(firstMatch));\n      }\n    } else {\n      // No match found, clear the timeout and the search term.\n      clearTimeout(this._searchTimeout);\n      this._searchString = '';\n    }\n  }\n\n  private _selectByKeyboard(): void {\n    const activeOption = this._selectableOptions()[this._activeItemIndex];\n\n    if (this.multiple) {\n      activeOption?.['selectViaUserInteraction'](!activeOption.selected);\n    } else {\n      this.close();\n    }\n  }\n\n  private _setNextActiveOption(event: KeyboardEvent, index?: number): void {\n    const filteredOptions = this._selectableOptions();\n\n    // Prevent keyboard navigation if all options are disabled\n    if (filteredOptions.length === 0) {\n      return;\n    }\n\n    const nextIndex =\n      index ?? getNextElementIndex(event, this._activeItemIndex, filteredOptions.length);\n    const nextOption = filteredOptions[nextIndex];\n    const activeOption = filteredOptions[this._activeItemIndex];\n\n    this._setActiveElement(nextOption, activeOption);\n\n    if (!this.multiple) {\n      this._setSelectedElement(nextOption, activeOption);\n    } else if (event?.shiftKey) {\n      nextOption['selectViaUserInteraction'](!nextOption.selected);\n    }\n    this._activeItemIndex = nextIndex;\n  }\n\n  private _setActiveElement(\n    nextActiveOption: SbbOptionElement<T>,\n    lastActiveOption: SbbOptionElement<T> | null = null,\n    setActiveDescendant = true,\n  ): void {\n    nextActiveOption.setActive(true);\n    nextActiveOption.scrollIntoView({ block: 'nearest' });\n\n    if (setActiveDescendant) {\n      this._triggerElement?.setAttribute('aria-activedescendant', nextActiveOption.id);\n    }\n\n    // Reset the previous\n    if (lastActiveOption && !this.compareWith(lastActiveOption.value, nextActiveOption.value)) {\n      lastActiveOption.setActive(false);\n    }\n  }\n\n  private _setSelectedElement(\n    nextActiveOption: SbbOptionElement<T>,\n    lastActiveOption: SbbOptionElement<T>,\n  ): void {\n    nextActiveOption['selectViaUserInteraction'](true);\n\n    if (lastActiveOption && !this.compareWith(lastActiveOption.value, nextActiveOption.value)) {\n      lastActiveOption['selectViaUserInteraction'](false);\n    }\n  }\n\n  private _resetActiveElement(): void {\n    const activeElement = this._selectableOptions()[this._activeItemIndex];\n\n    if (activeElement) {\n      activeElement.setActive(false);\n    }\n    this._activeItemIndex = -1;\n    this._triggerElement?.removeAttribute('aria-activedescendant');\n  }\n\n  // Check if the pointerdown event target is triggered on the menu.\n  private _pointerDownListener = (event: PointerEvent): void => {\n    this._isPointerDownEventOnMenu = isEventOnElement(this._overlay, event);\n  };\n\n  // Close menu on backdrop click.\n  private _closeOnBackdropClick = (event: PointerEvent): void => {\n    if (\n      !this._isPointerDownEventOnMenu &&\n      !isEventOnElement(this._overlay, event) &&\n      !isEventOnElement(this._originElement, event)\n    ) {\n      this.close();\n    }\n  };\n\n  private _updateOptionsFromValue(): void {\n    const value = Array.isArray(this.value) ? this.value : [this.value];\n\n    const displayValues = [];\n    for (const option of this.options) {\n      option.selected = value.some((v) => this.compareWith(v, option.value));\n      if (option.selected) {\n        displayValues.push(option);\n      }\n    }\n\n    this._updateDisplayValue();\n\n    if (!Array.isArray(this.value)) {\n      const value: T | null = this.value;\n      this._activeItemIndex = this._selectableOptions().findIndex((option) =>\n        this.compareWith(option.value, value),\n      );\n    }\n  }\n\n  private _updateValueFromOptions(): void {\n    const selected = this._getSelected();\n\n    if (Array.isArray(selected)) {\n      if (selected && selected.length > 0) {\n        const value: T[] = [];\n        for (const option of selected) {\n          value.push(option.value!);\n        }\n        this._value = value;\n      }\n    } else if (selected) {\n      this._activeItemIndex = this._selectableOptions().findIndex((option) => option === selected);\n      this._value = selected.value;\n    }\n\n    this._updateDisplayValue();\n  }\n\n  private _updateValueOptionState(): void {\n    if (this._isValueManuallyAssigned) {\n      this._updateOptionsFromValue();\n    } else {\n      this._updateValueFromOptions();\n    }\n  }\n\n  private _getSelected(): SbbOptionElement<T> | SbbOptionElement<T>[] | null {\n    if (this.multiple) {\n      return this.options.filter((option) => option.selected);\n    } else {\n      return this.options.find((option) => option.selected) ?? null;\n    }\n  }\n\n  private _toggleOpening(): void {\n    if (this.disabled || this.formDisabled || this.readOnly) {\n      return;\n    }\n    this._triggerElement?.focus();\n\n    switch (this.state) {\n      case 'opening':\n      case 'opened': {\n        this.close();\n        break;\n      }\n      case 'closing':\n      case 'closed': {\n        this.open();\n        break;\n      }\n      default:\n        break;\n    }\n  }\n\n  private _spreadDeferredDisplayValue(\n    placeholder: TemplateResult,\n  ): (TemplateResult | Promise<TemplateResult>)[] {\n    return [this._deferredDisplayValue(placeholder), placeholder];\n  }\n\n  private async _deferredDisplayValue(placeholder: TemplateResult): Promise<TemplateResult> {\n    if (this.hydrationRequired) {\n      await this.hydrationComplete;\n    }\n    return this._displayValue ? html`${this._displayValue}` : placeholder;\n  }\n\n  protected override render(): TemplateResult {\n    // Scroll areas without containing an interactive element will receive focus when tabbing through the document.\n    // If there are a lot of options and when pressing tab key, the scroll area on sbb-select__options gets focus.\n    // As elements inside the panel should never get focus, we have to avoid that by setting tabindex=-1.\n\n    return html`\n      <!-- This element is visually hidden and will be appended to the light DOM to allow screen\n      readers to work properly -->\n      <div\n        class=\"sbb-screen-reader-only sbb-select-trigger\"\n        tabindex=${this.disabled || this.formDisabled ? nothing : '0'}\n        role=\"combobox\"\n        aria-haspopup=\"listbox\"\n        aria-expanded=\"false\"\n        aria-required=${this.required.toString()}\n        aria-controls=${this._overlayId}\n        aria-owns=${this._overlayId}\n        @keydown=${this._onKeyDown}\n        @click=${this._toggleOpening}\n        ${ref((ref) => (this._triggerElement = ref as HTMLElement))}\n      >\n        ${until(...this._spreadDeferredDisplayValue(html`${this.placeholder}`))}\n      </div>\n\n      <!-- Visually display the value -->\n      <div class=\"sbb-select__trigger\" aria-hidden=\"true\">\n        ${until(...this._spreadDeferredDisplayValue(html`${this.placeholder}`))}\n      </div>\n\n      <div class=\"sbb-option-panel__overlay-container sbb-popover-reset\" popover=\"manual\">\n        <div\n          class=\"sbb-option-panel__overlay ${this.negative\n            ? 'sbb-scrollbar-negative'\n            : 'sbb-scrollbar'}\"\n          id=${!ariaRoleOnHost ? this._overlayId : nothing}\n          role=${!ariaRoleOnHost ? 'listbox' : nothing}\n          ?aria-multiselectable=${this.multiple}\n          tabindex=\"-1\"\n          @animationend=${this._onAnimationEnd}\n          ${ref((dialogRef) => (this._overlay = dialogRef as HTMLElement))}\n        >\n          <slot @slotchange=${this._updateValueOptionState}></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-select': SbbSelectElement;\n  }\n}\n"],"mappings":"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"}