@sbb-esta/lyne-elements 5.0.0-next.3 → 5.0.1

package/development/autocomplete-base-element-DtwUdjCd.js

@@ -0,0 +1,695 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, nothing, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbEscapableOverlayController, SbbNegativeMixin, SbbOpenCloseBaseElement, SbbPropertyWatcherController, forceType, idReference, isEventOnElement, isSafari, isZeroAnimationDuration, popoverResetStyles, removeAriaComboBoxAttributes, scrollbarStyles, 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";
+//#region src/elements/autocomplete/autocomplete-base-element.scss?inline
+var autocomplete_base_element_default = ":host {\n  display: none;\n}\n\n:host(:is(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]), :is(:state(state-closing),[state--state-closing]))) {\n  display: block;\n}";
+//#endregion
+//#region src/elements/autocomplete/autocomplete-base-element.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 "closer" to the options, or else optgroups won't work.
+*/
+var ariaRoleOnHost = isSafari;
+var SbbInputAutocompleteEvent = class extends Event {
+	get option() {
+		return this._option;
+	}
+	constructor(option) {
+		super("inputAutocomplete", {
+			bubbles: true,
+			composed: true
+		});
+		this._option = option;
+	}
+};
+/**
+* Base class for autocomplete components.
+*
+* @event {Event} change - The change event is fired on the autocomplete's trigger 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.
+* @event {InputEvent} input - The input event fires  on the autocomplete's trigger when the value has been changed as a direct result of a user action.
+*/
+var SbbAutocompleteBaseElement = (() => {
+	let _classSuper = SbbNegativeMixin(SbbOpenCloseBaseElement);
+	let _origin_decorators;
+	let _origin_initializers = [];
+	let _origin_extraInitializers = [];
+	let _trigger_decorators;
+	let _trigger_initializers = [];
+	let _trigger_extraInitializers = [];
+	let _preserveIconSpace_decorators;
+	let _preserveIconSpace_initializers = [];
+	let _preserveIconSpace_extraInitializers = [];
+	let _autoActiveFirstOption_decorators;
+	let _autoActiveFirstOption_initializers = [];
+	let _autoActiveFirstOption_extraInitializers = [];
+	let _displayWith_decorators;
+	let _displayWith_initializers = [];
+	let _displayWith_extraInitializers = [];
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	let _autoSelectActiveOption_decorators;
+	let _autoSelectActiveOption_initializers = [];
+	let _autoSelectActiveOption_extraInitializers = [];
+	let _autoSelectActiveOptionOnBlur_decorators;
+	let _autoSelectActiveOptionOnBlur_initializers = [];
+	let _autoSelectActiveOptionOnBlur_extraInitializers = [];
+	let _requireSelection_decorators;
+	let _requireSelection_initializers = [];
+	let _requireSelection_extraInitializers = [];
+	let _position_decorators;
+	let _position_initializers = [];
+	let _position_extraInitializers = [];
+	return class SbbAutocompleteBaseElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_origin_decorators = [idReference(), property()];
+			_trigger_decorators = [idReference(), property()];
+			_preserveIconSpace_decorators = [forceType(), property({
+				attribute: "preserve-icon-space",
+				reflect: true,
+				type: Boolean
+			})];
+			_autoActiveFirstOption_decorators = [forceType(), property({
+				attribute: "auto-active-first-option",
+				type: Boolean
+			})];
+			_displayWith_decorators = [property({ attribute: false })];
+			_size_decorators = [property({ reflect: true })];
+			_autoSelectActiveOption_decorators = [forceType(), property({
+				attribute: "auto-select-active-option",
+				type: Boolean
+			})];
+			_autoSelectActiveOptionOnBlur_decorators = [forceType(), property({
+				attribute: "auto-select-active-option-on-blur",
+				type: Boolean
+			})];
+			_requireSelection_decorators = [forceType(), property({
+				attribute: "require-selection",
+				type: Boolean
+			})];
+			_position_decorators = [property()];
+			__esDecorate(this, null, _origin_decorators, {
+				kind: "accessor",
+				name: "origin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "origin" in obj,
+					get: (obj) => obj.origin,
+					set: (obj, value) => {
+						obj.origin = value;
+					}
+				},
+				metadata: _metadata
+			}, _origin_initializers, _origin_extraInitializers);
+			__esDecorate(this, null, _trigger_decorators, {
+				kind: "accessor",
+				name: "trigger",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "trigger" in obj,
+					get: (obj) => obj.trigger,
+					set: (obj, value) => {
+						obj.trigger = value;
+					}
+				},
+				metadata: _metadata
+			}, _trigger_initializers, _trigger_extraInitializers);
+			__esDecorate(this, null, _preserveIconSpace_decorators, {
+				kind: "accessor",
+				name: "preserveIconSpace",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "preserveIconSpace" in obj,
+					get: (obj) => obj.preserveIconSpace,
+					set: (obj, value) => {
+						obj.preserveIconSpace = value;
+					}
+				},
+				metadata: _metadata
+			}, _preserveIconSpace_initializers, _preserveIconSpace_extraInitializers);
+			__esDecorate(this, null, _autoActiveFirstOption_decorators, {
+				kind: "accessor",
+				name: "autoActiveFirstOption",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "autoActiveFirstOption" in obj,
+					get: (obj) => obj.autoActiveFirstOption,
+					set: (obj, value) => {
+						obj.autoActiveFirstOption = value;
+					}
+				},
+				metadata: _metadata
+			}, _autoActiveFirstOption_initializers, _autoActiveFirstOption_extraInitializers);
+			__esDecorate(this, null, _displayWith_decorators, {
+				kind: "accessor",
+				name: "displayWith",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "displayWith" in obj,
+					get: (obj) => obj.displayWith,
+					set: (obj, value) => {
+						obj.displayWith = value;
+					}
+				},
+				metadata: _metadata
+			}, _displayWith_initializers, _displayWith_extraInitializers);
+			__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, _autoSelectActiveOption_decorators, {
+				kind: "accessor",
+				name: "autoSelectActiveOption",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "autoSelectActiveOption" in obj,
+					get: (obj) => obj.autoSelectActiveOption,
+					set: (obj, value) => {
+						obj.autoSelectActiveOption = value;
+					}
+				},
+				metadata: _metadata
+			}, _autoSelectActiveOption_initializers, _autoSelectActiveOption_extraInitializers);
+			__esDecorate(this, null, _autoSelectActiveOptionOnBlur_decorators, {
+				kind: "accessor",
+				name: "autoSelectActiveOptionOnBlur",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "autoSelectActiveOptionOnBlur" in obj,
+					get: (obj) => obj.autoSelectActiveOptionOnBlur,
+					set: (obj, value) => {
+						obj.autoSelectActiveOptionOnBlur = value;
+					}
+				},
+				metadata: _metadata
+			}, _autoSelectActiveOptionOnBlur_initializers, _autoSelectActiveOptionOnBlur_extraInitializers);
+			__esDecorate(this, null, _requireSelection_decorators, {
+				kind: "accessor",
+				name: "requireSelection",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "requireSelection" in obj,
+					get: (obj) => obj.requireSelection,
+					set: (obj, value) => {
+						obj.requireSelection = value;
+					}
+				},
+				metadata: _metadata
+			}, _requireSelection_initializers, _requireSelection_extraInitializers);
+			__esDecorate(this, null, _position_decorators, {
+				kind: "accessor",
+				name: "position",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "position" in obj,
+					get: (obj) => obj.position,
+					set: (obj, value) => {
+						obj.position = value;
+					}
+				},
+				metadata: _metadata
+			}, _position_initializers, _position_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.styles = [
+				popoverResetStyles,
+				scrollbarStyles,
+				optionPanelStyles,
+				unsafeCSS(autocomplete_base_element_default)
+			];
+		}
+		#origin_accessor_storage;
+		/**
+		* The element where the autocomplete will attach.
+		* If not set, as fallback there are two elements which can act as origin with following priority order:
+		* 1. `sbb-form-field` if it is an ancestor.
+		* 2. trigger element if set.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get origin() {
+			return this.#origin_accessor_storage;
+		}
+		set origin(value) {
+			this.#origin_accessor_storage = value;
+		}
+		#trigger_accessor_storage;
+		/**
+		* The input element that will trigger the autocomplete opening.
+		* By default, the autocomplete will open on focus, click, input or `ArrowDown` keypress of the 'trigger' element.
+		* If not set, will search for the first 'input' child of a 'sbb-form-field' ancestor.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get trigger() {
+			return this.#trigger_accessor_storage;
+		}
+		set trigger(value) {
+			this.#trigger_accessor_storage = value;
+		}
+		#preserveIconSpace_accessor_storage;
+		/** Whether the icon space is preserved when no icon is set. */
+		get preserveIconSpace() {
+			return this.#preserveIconSpace_accessor_storage;
+		}
+		set preserveIconSpace(value) {
+			this.#preserveIconSpace_accessor_storage = value;
+		}
+		#autoActiveFirstOption_accessor_storage;
+		/** Whether the first option is automatically activated when the autocomplete is opened. */
+		get autoActiveFirstOption() {
+			return this.#autoActiveFirstOption_accessor_storage;
+		}
+		set autoActiveFirstOption(value) {
+			this.#autoActiveFirstOption_accessor_storage = value;
+		}
+		#displayWith_accessor_storage;
+		/** Function that maps an option's control value to its display value in the trigger. */
+		get displayWith() {
+			return this.#displayWith_accessor_storage;
+		}
+		set displayWith(value) {
+			this.#displayWith_accessor_storage = 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;
+		}
+		#autoSelectActiveOption_accessor_storage;
+		/** Whether the active option should be selected as the user is navigating. */
+		get autoSelectActiveOption() {
+			return this.#autoSelectActiveOption_accessor_storage;
+		}
+		set autoSelectActiveOption(value) {
+			this.#autoSelectActiveOption_accessor_storage = value;
+		}
+		#autoSelectActiveOptionOnBlur_accessor_storage;
+		/**
+		* When enabled, the active option is automatically selected on blur.
+		* This is an experimental feature. It might be subject to changes.
+		*/
+		get autoSelectActiveOptionOnBlur() {
+			return this.#autoSelectActiveOptionOnBlur_accessor_storage;
+		}
+		set autoSelectActiveOptionOnBlur(value) {
+			this.#autoSelectActiveOptionOnBlur_accessor_storage = value;
+		}
+		#requireSelection_accessor_storage;
+		/**
+		* Whether the user is required to make a selection when they're interacting with the
+		* autocomplete. If the user moves away from the autocomplete without selecting an option from
+		* the list, the value will be reset. If the user opens the panel and closes it without
+		* interacting or selecting a value, the initial value will be kept.
+		*/
+		get requireSelection() {
+			return this.#requireSelection_accessor_storage;
+		}
+		set requireSelection(value) {
+			this.#requireSelection_accessor_storage = value;
+		}
+		#position_accessor_storage;
+		/**
+		* The position of the autocomplete panel relative to the trigger.
+		* @default 'auto'
+		*/
+		get position() {
+			return this.#position_accessor_storage;
+		}
+		set position(value) {
+			this.#position_accessor_storage = value;
+		}
+		/** Returns the element where the autocomplete overlay is attached to. */
+		get originElement() {
+			return this.origin ?? this.closest?.("sbb-form-field")?.shadowRoot?.querySelector?.("#overlay-anchor") ?? this.trigger ?? null;
+		}
+		/** Returns the trigger element. */
+		get triggerElement() {
+			return this._triggerElement ?? null;
+		}
+		constructor() {
+			super();
+			this.#origin_accessor_storage = __runInitializers(this, _origin_initializers, null);
+			this.#trigger_accessor_storage = (__runInitializers(this, _origin_extraInitializers), __runInitializers(this, _trigger_initializers, null));
+			this.#preserveIconSpace_accessor_storage = (__runInitializers(this, _trigger_extraInitializers), __runInitializers(this, _preserveIconSpace_initializers, false));
+			this.#autoActiveFirstOption_accessor_storage = (__runInitializers(this, _preserveIconSpace_extraInitializers), __runInitializers(this, _autoActiveFirstOption_initializers, false));
+			this.#displayWith_accessor_storage = (__runInitializers(this, _autoActiveFirstOption_extraInitializers), __runInitializers(this, _displayWith_initializers, null));
+			this.#size_accessor_storage = (__runInitializers(this, _displayWith_extraInitializers), __runInitializers(this, _size_initializers, null));
+			this.#autoSelectActiveOption_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _autoSelectActiveOption_initializers, false));
+			this.#autoSelectActiveOptionOnBlur_accessor_storage = (__runInitializers(this, _autoSelectActiveOption_extraInitializers), __runInitializers(this, _autoSelectActiveOptionOnBlur_initializers, false));
+			this.#requireSelection_accessor_storage = (__runInitializers(this, _autoSelectActiveOptionOnBlur_extraInitializers), __runInitializers(this, _requireSelection_initializers, false));
+			this.#position_accessor_storage = (__runInitializers(this, _requireSelection_extraInitializers), __runInitializers(this, _position_initializers, "auto"));
+			this._triggerElement = __runInitializers(this, _position_extraInitializers);
+			this.activeOption = null;
+			this.pendingAutoSelectedOption = null;
+			this._resizeObserver = new ResizeController(this, {
+				target: null,
+				skipInitial: true,
+				callback: (() => {
+					let timeoutId;
+					return () => {
+						clearTimeout(timeoutId);
+						timeoutId = setTimeout(() => {
+							if (this.state !== "closed") this._setOverlayPosition();
+						}, 10);
+					};
+				})()
+			});
+			/** Listens to the changes on the `disabled` or `readonly` attribute of the trigger. */
+			this._triggerAttributeObserver = !isServer ? new MutationObserver((mutations) => {
+				const input = mutations[0].target;
+				if (input.hasAttribute("disabled") || input.hasAttribute("readonly")) this.close();
+			}) : null;
+			this._isPointerDownEventOnMenu = false;
+			this._escapableOverlayController = new SbbEscapableOverlayController(this);
+			this._optionsCount = 0;
+			/** Tracks input from keyboard. */
+			this._lastUserInput = null;
+			/** If true, the 'change' event source is an option selection or a 'requireSelection' field cleanup */
+			this._isCustomChangeEvent = 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?.("optionselected", (e) => this.onOptionSelected(e));
+			this.addEventListener?.("ɵoptgroupslotchange", () => this._handleSlotchange(), { capture: true });
+			this.addController(new SbbPropertyWatcherController(this, () => this.closest("sbb-form-field"), {
+				negative: (e) => {
+					this.negative = e.negative;
+					this.syncNegative();
+				},
+				borderless: (e) => this.toggleState("option-panel-origin-borderless", e.borderless)
+			}));
+		}
+		/** Opens the autocomplete. */
+		open() {
+			if (this.state === "opening" || this.state === "opened" || !this._overlay || this.options.length === 0 || this._readonly() || !this.dispatchBeforeOpenEvent()) return;
+			this.showPopover?.();
+			this.state = "opening";
+			this.triggerElement?.toggleAttribute("data-expanded", true);
+			const originElement = this.originElement;
+			if (!originElement) throw new Error("Cannot find the origin element. Please specify a valid element or check the usage of the \"origin\" property from the documentation");
+			this._setOverlayPosition(originElement);
+			this._setNextActiveOptionIfAutoActiveFirstOption();
+			this._attachOpenPanelEvents();
+			this._escapableOverlayController.connect();
+			if (this._isZeroAnimationDuration()) this._handleOpening();
+		}
+		/** Closes the autocomplete. */
+		close() {
+			if (this.state === "closing" || this.state === "closed" || !this.dispatchBeforeCloseEvent()) return;
+			if (this.pendingAutoSelectedOption) {
+				this.pendingAutoSelectedOption.selected = true;
+				this._setValueAndDispatchEvents(this.pendingAutoSelectedOption, true);
+			}
+			this.state = "closing";
+			this.triggerElement?.removeAttribute("data-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");
+		}
+		connectedCallback() {
+			this.popover = "manual";
+			super.connectedCallback();
+			if (ariaRoleOnHost) this.id ||= this.overlayId;
+			if (this.hasUpdated) this._componentSetup();
+			this.syncNegative();
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("negative")) this.syncNegative();
+			if (changedProperties.has("autoActiveFirstOption") && this.isOpen) this._setNextActiveOptionIfAutoActiveFirstOption();
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this._componentSetup();
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this._triggerElement = null;
+			this._triggerAbortController?.abort();
+			this._openPanelEventsController?.abort();
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (isServer || !this.hasUpdated) return;
+			if (!name || name === "trigger") this._configureTrigger();
+			else if ((!name || name === "origin") && this.isOpen) this._setOverlayPosition();
+		}
+		/** When an option is selected, update the input value and close the autocomplete. */
+		onOptionSelected(event) {
+			const target = event.target;
+			this._setValueAndDispatchEvents(target);
+			this.close();
+		}
+		/**
+		* A 'pending selection' sets the option value in the input element without emitting events.
+		* A 'pending selection' is confirmed when the panel closes. Any other user interaction
+		* will reset the pending value.
+		*/
+		setPendingSelection(activeOption) {
+			this.pendingAutoSelectedOption = activeOption;
+			this._setInputValue(activeOption);
+		}
+		_setValueAndDispatchEvents(selectedOption, preventFocus = false) {
+			this.options.filter((option) => option !== selectedOption && option.selected).forEach((option) => option.selected = false);
+			this.pendingAutoSelectedOption = null;
+			if (this.triggerElement) {
+				this._setInputValue(selectedOption);
+				this._isCustomChangeEvent = true;
+				this.triggerElement.dispatchEvent(new Event("change", { bubbles: true }));
+				this.triggerElement.dispatchEvent(new InputEvent("input", {
+					bubbles: true,
+					composed: true
+				}));
+				this._lastUserInput = null;
+				this.triggerElement.dispatchEvent(new SbbInputAutocompleteEvent(selectedOption));
+				if (!preventFocus) this.triggerElement.focus();
+			}
+		}
+		/** Set the option value within the input element */
+		_setInputValue(option) {
+			if (!this.triggerElement) return;
+			const toDisplay = this.displayWith?.(option.value) ?? option.value;
+			Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value").set.call(this.triggerElement, toDisplay);
+		}
+		_handleSlotchange() {
+			this._highlightOptions(this.triggerElement?.value);
+			const currentElements = Array.from(this.querySelectorAll("*"));
+			this._previousElements?.forEach((e) => this._resizeObserver.unobserve(e));
+			this._previousElements = currentElements;
+			this._previousElements.forEach((e) => this._resizeObserver.observe(e));
+			/**
+			* It's possible to filter out options with an opened panel on input change.
+			* In this case, the panel's position must be recalculated considering the new option's list.
+			*/
+			if (this.isOpen) {
+				this._setOverlayPosition();
+				this._setNextActiveOptionIfAutoActiveFirstOption();
+				if (this._optionsCount > 0 && this.options.length === 0) this.close();
+			} else if (document?.activeElement === this.triggerElement && this._optionsCount === 0 && this.options.length > 0) this.open();
+			this._optionsCount = this.options.length;
+		}
+		_setNextActiveOptionIfAutoActiveFirstOption() {
+			if (this.autoActiveFirstOption) {
+				this.resetActiveElement();
+				this.setNextActiveOption();
+			}
+		}
+		/** The autocomplete should inherit 'readonly' state from the trigger. */
+		_readonly() {
+			return this.triggerElement?.hasAttribute("readonly") ?? false;
+		}
+		_componentSetup() {
+			if (isServer) return;
+			this._configureTrigger();
+		}
+		_configureTrigger() {
+			const triggerElement = this.trigger ?? this.closest?.("sbb-form-field")?.querySelector("input");
+			if (triggerElement === this.triggerElement) return;
+			this._triggerAbortController?.abort();
+			removeAriaComboBoxAttributes(this.triggerElement);
+			this.triggerElement?.removeAttribute("data-expanded");
+			this._triggerElement = triggerElement;
+			if (!this.triggerElement) return;
+			const originElement = this.originElement;
+			if (this.triggerElement === originElement && this.isOpen) this._setOverlayPosition(originElement);
+			this._triggerAttributeObserver?.observe(this.triggerElement, {
+				attributes: true,
+				attributeFilter: ["disabled", "readonly"]
+			});
+			this.setTriggerAttributes(this.triggerElement);
+			this._triggerAbortController = new AbortController();
+			this.triggerElement.addEventListener("focus", () => this.open(), { signal: this._triggerAbortController.signal });
+			this.triggerElement.addEventListener("click", () => this.open(), { signal: this._triggerAbortController.signal });
+			this.triggerElement.addEventListener("input", (event) => {
+				const value = event.target.value;
+				if (value && event.isTrusted) this.open();
+				this._highlightOptions(value);
+				this._lastUserInput = value;
+				this.pendingAutoSelectedOption = null;
+			}, { signal: this._triggerAbortController.signal });
+			this.triggerElement.addEventListener("change", (event) => {
+				/**
+				* In 'requireSelection' mode, we block the native change events and
+				* let only pass the ones that come with a valid value (when an option is selected)
+				*/
+				if (this.requireSelection && !this._isCustomChangeEvent) event.stopImmediatePropagation();
+				this._isCustomChangeEvent = false;
+			}, {
+				signal: this._triggerAbortController.signal,
+				capture: true
+			});
+			this.triggerElement.addEventListener("keydown", (event) => this._closedPanelKeyboardInteraction(event), {
+				signal: this._triggerAbortController.signal,
+				capture: true
+			});
+			this.triggerElement.addEventListener("blur", (e) => {
+				if (this.contains(e.relatedTarget)) return;
+				if (this.autoSelectActiveOptionOnBlur && this.activeOption && this._lastUserInput && this.triggerElement?.value) {
+					this.activeOption.selected = true;
+					this._setValueAndDispatchEvents(this.activeOption, true);
+				}
+				if (this.requireSelection && this.triggerElement && this._lastUserInput != null && !this.pendingAutoSelectedOption) {
+					Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value").set.call(this.triggerElement, "");
+					this._highlightOptions("");
+					this._isCustomChangeEvent = true;
+					this.triggerElement.dispatchEvent(new Event("change", { bubbles: true }));
+					this.triggerElement.dispatchEvent(new InputEvent("input", {
+						bubbles: true,
+						composed: true
+					}));
+				}
+				this.close();
+			}, {
+				signal: this._triggerAbortController.signal,
+				capture: true
+			});
+		}
+		_setOverlayPosition(originElement = this.originElement) {
+			if (!originElement) return;
+			setOverlayPosition(this._overlay, originElement, this._overlay, this.shadowRoot.querySelector(".sbb-option-panel__overlay-container"), this, this.position);
+		}
+		/**
+		* On open/close animation end.
+		* In rare cases it can be that the animationEnd event is triggered twice.
+		* To avoid entering a corrupt state, exit when state is not expected.
+		*/
+		_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";
+			if (this.originElement) this._resizeObserver.observe(this.originElement);
+			this.triggerElement?.setAttribute("aria-expanded", "true");
+			this.dispatchOpenEvent();
+		}
+		_handleClosing() {
+			this.state = "closed";
+			this.hidePopover?.();
+			this.triggerElement?.setAttribute("aria-expanded", "false");
+			this.resetActiveElement();
+			this._overlay.scrollTop = 0;
+			this._escapableOverlayController.disconnect();
+			this.dispatchCloseEvent();
+		}
+		_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 });
+			this.addEventListener("ɵdisabledchange", () => {
+				if (this.activeOption?.disabled) this.resetActiveElement();
+				this._setNextActiveOptionIfAutoActiveFirstOption();
+			}, { signal: this._openPanelEventsController.signal });
+			this.triggerElement?.addEventListener("keydown", (event) => this.openedPanelKeyboardInteraction(event), {
+				signal: this._openPanelEventsController.signal,
+				capture: true
+			});
+		}
+		_closedPanelKeyboardInteraction(event) {
+			if (this.state === "opening" || this.state === "opened") return;
+			switch (event.key) {
+				case "ArrowDown":
+				case "ArrowUp":
+					this.open();
+					break;
+			}
+		}
+		/** Highlight the searched text on the options. */
+		_highlightOptions(searchTerm) {
+			if (searchTerm === null || searchTerm === void 0) return;
+			this.options.forEach((option) => option.highlight(searchTerm));
+		}
+		render() {
+			return html`
+      <div class="sbb-option-panel__overlay-container">
+        <div
+          class="sbb-option-panel__overlay ${this.negative ? "sbb-scrollbar-negative" : "sbb-scrollbar"}"
+          role=${!ariaRoleOnHost ? this.panelRole : nothing}
+          id=${!ariaRoleOnHost ? this.overlayId : nothing}
+          tabindex="-1"
+          @animationend=${this._onAnimationEnd}
+          ${ref((overlayRef) => this._overlay = overlayRef)}
+        >
+          <slot @slotchange=${this._handleSlotchange}></slot>
+        </div>
+      </div>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbInputAutocompleteEvent as n, SbbAutocompleteBaseElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"autocomplete-base-element-DtwUdjCd.js","names":[],"sources":["../../../src/elements/autocomplete/autocomplete-base-element.scss?inline","../../../src/elements/autocomplete/autocomplete-base-element.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  display: none;\n}\n\n:host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) {\n  display: block;\n}\n","import { 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 } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport {\n  forceType,\n  idReference,\n  isEventOnElement,\n  isSafari,\n  isZeroAnimationDuration,\n  popoverResetStyles,\n  removeAriaComboBoxAttributes,\n  SbbEscapableOverlayController,\n  SbbNegativeMixin,\n  SbbOpenCloseBaseElement,\n  SbbPropertyWatcherController,\n  scrollbarStyles,\n  setOverlayPosition,\n} from '../core.ts';\nimport type { SbbFormFieldElement } from '../form-field/form-field/form-field.component.ts';\nimport { optionPanelStyles, type SbbOptionBaseElement } from '../option.pure.ts';\n\nimport style from './autocomplete-base-element.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 \"closer\" to the options, or else optgroups won't work.\n */\nconst ariaRoleOnHost = isSafari;\n\nexport class SbbInputAutocompleteEvent<T> extends Event {\n  private readonly _option: SbbOptionBaseElement<T>;\n\n  public get option(): SbbOptionBaseElement<T> {\n    return this._option;\n  }\n\n  public constructor(option: SbbOptionBaseElement<T>) {\n    super('inputAutocomplete', { bubbles: true, composed: true });\n    this._option = option;\n  }\n}\n\n/**\n * Base class for autocomplete components.\n *\n * @event {Event} change - The change event is fired on the autocomplete's trigger 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.\n * @event {InputEvent} input - The input event fires  on the autocomplete's trigger when the value has been changed as a direct result of a user action.\n */\nexport abstract class SbbAutocompleteBaseElement<T = string> extends SbbNegativeMixin(\n  SbbOpenCloseBaseElement,\n) {\n  public static override styles: CSSResultGroup = [\n    popoverResetStyles,\n    scrollbarStyles,\n    optionPanelStyles,\n    unsafeCSS(style),\n  ];\n\n  /**\n   * The element where the autocomplete will attach.\n   * If not set, as fallback there are two elements which can act as origin with following priority order:\n   * 1. `sbb-form-field` if it is an ancestor.\n   * 2. trigger element if set.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property()\n  public accessor origin: HTMLElement | null = null;\n\n  /**\n   * The input element that will trigger the autocomplete opening.\n   * By default, the autocomplete will open on focus, click, input or `ArrowDown` keypress of the 'trigger' element.\n   * If not set, will search for the first 'input' child of a 'sbb-form-field' ancestor.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property()\n  public accessor trigger: HTMLInputElement | null = null;\n\n  /** Whether the icon space is preserved when no icon is set. */\n  @forceType()\n  @property({ attribute: 'preserve-icon-space', reflect: true, type: Boolean })\n  public accessor preserveIconSpace: boolean = false;\n\n  /** Whether the first option is automatically activated when the autocomplete is opened. */\n  @forceType()\n  @property({ attribute: 'auto-active-first-option', type: Boolean })\n  public accessor autoActiveFirstOption: boolean = false;\n\n  /** Function that maps an option's control value to its display value in the trigger. */\n  @property({ attribute: false })\n  public accessor displayWith: ((value: T) => string) | 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  /** Whether the active option should be selected as the user is navigating. */\n  @forceType()\n  @property({ attribute: 'auto-select-active-option', type: Boolean })\n  public accessor autoSelectActiveOption: boolean = false;\n\n  /**\n   * When enabled, the active option is automatically selected on blur.\n   * This is an experimental feature. It might be subject to changes.\n   */\n  @forceType()\n  @property({ attribute: 'auto-select-active-option-on-blur', type: Boolean })\n  public accessor autoSelectActiveOptionOnBlur: boolean = false;\n\n  /**\n   * Whether the user is required to make a selection when they're interacting with the\n   * autocomplete. If the user moves away from the autocomplete without selecting an option from\n   * the list, the value will be reset. If the user opens the panel and closes it without\n   * interacting or selecting a value, the initial value will be kept.\n   */\n  @forceType()\n  @property({ attribute: 'require-selection', type: Boolean })\n  public accessor requireSelection: boolean = false;\n\n  /**\n   * The position of the autocomplete panel relative to the trigger.\n   * @default 'auto'\n   */\n  @property()\n  public accessor position: 'auto' | 'above' | 'below' = 'auto';\n\n  /** Returns the element where the autocomplete overlay is attached to. */\n  public get originElement(): HTMLElement | null {\n    return (\n      this.origin ??\n      this.closest?.('sbb-form-field')?.shadowRoot?.querySelector?.('#overlay-anchor') ??\n      this.trigger ??\n      null\n    );\n  }\n\n  /** Returns the trigger element. */\n  public get triggerElement(): HTMLInputElement | null {\n    return this._triggerElement ?? null;\n  }\n  private _triggerElement?: HTMLInputElement | null;\n\n  protected abstract overlayId: string;\n  protected abstract panelRole: string;\n  protected activeOption: SbbOptionBaseElement<T> | null = null;\n  protected pendingAutoSelectedOption: SbbOptionBaseElement<T> | null = null;\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  /** Listens to the changes on the `disabled` or `readonly` attribute of the trigger. */\n  private _triggerAttributeObserver = !isServer\n    ? new MutationObserver((mutations: MutationRecord[]): void => {\n        const input = mutations[0].target as HTMLInputElement;\n        if (input.hasAttribute('disabled') || input.hasAttribute('readonly')) {\n          this.close();\n        }\n      })\n    : null;\n  private _overlay!: HTMLElement;\n  private _triggerAbortController!: AbortController;\n  private _openPanelEventsController!: AbortController;\n  private _isPointerDownEventOnMenu: boolean = false;\n  private _escapableOverlayController = new SbbEscapableOverlayController(this);\n  private _optionsCount = 0;\n  private _previousElements?: Element[];\n\n  /** Tracks input from keyboard. */\n  private _lastUserInput: string | null = null;\n\n  /** If true, the 'change' event source is an option selection or a 'requireSelection' field cleanup */\n  private _isCustomChangeEvent = false;\n\n  protected abstract get options(): SbbOptionBaseElement<T>[];\n\n  public constructor() {\n    super();\n    this.addEventListener?.('optionselected', (e: Event) => this.onOptionSelected(e));\n    this.addEventListener?.('ɵoptgroupslotchange', () => this._handleSlotchange(), {\n      capture: true,\n    });\n    this.addController(\n      new SbbPropertyWatcherController(\n        this,\n        () => this.closest<SbbFormFieldElement>('sbb-form-field'),\n        {\n          negative: (e) => {\n            this.negative = e.negative;\n            this.syncNegative();\n          },\n          borderless: (e) => this.toggleState('option-panel-origin-borderless', e.borderless),\n        },\n      ),\n    );\n  }\n\n  protected abstract syncNegative(): void;\n  protected abstract setTriggerAttributes(element: HTMLInputElement): void;\n  protected abstract openedPanelKeyboardInteraction(event: KeyboardEvent): void;\n  protected abstract selectByKeyboard(event: KeyboardEvent): void;\n  protected abstract setNextActiveOption(event?: KeyboardEvent): void;\n  protected abstract resetActiveElement(): void;\n\n  /** Opens the autocomplete. */\n  public open(): void {\n    if (\n      this.state === 'opening' ||\n      this.state === 'opened' ||\n      !this._overlay ||\n      this.options.length === 0 ||\n      this._readonly() ||\n      !this.dispatchBeforeOpenEvent()\n    ) {\n      return;\n    }\n\n    this.showPopover?.();\n    this.state = 'opening';\n    this.triggerElement?.toggleAttribute('data-expanded', true);\n    const originElement = this.originElement;\n    if (!originElement) {\n      throw new Error(\n        'Cannot find the origin element. Please specify a valid element or check the usage of the \"origin\" property from the documentation',\n      );\n    }\n    this._setOverlayPosition(originElement);\n    this._setNextActiveOptionIfAutoActiveFirstOption();\n    this._attachOpenPanelEvents();\n    this._escapableOverlayController.connect();\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 autocomplete. */\n  public close(): void {\n    if (this.state === 'closing' || this.state === 'closed' || !this.dispatchBeforeCloseEvent()) {\n      return;\n    }\n\n    // A 'pending selection' is confirmed on panel close\n    if (this.pendingAutoSelectedOption) {\n      this.pendingAutoSelectedOption.selected = true;\n      this._setValueAndDispatchEvents(this.pendingAutoSelectedOption, true);\n    }\n\n    this.state = 'closing';\n    this.triggerElement?.removeAttribute('data-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  public override connectedCallback(): void {\n    this.popover = 'manual';\n    super.connectedCallback();\n    if (ariaRoleOnHost) {\n      this.id ||= this.overlayId;\n    }\n\n    if (this.hasUpdated) {\n      this._componentSetup();\n    }\n    this.syncNegative();\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('negative')) {\n      this.syncNegative();\n    }\n\n    if (changedProperties.has('autoActiveFirstOption') && this.isOpen) {\n      this._setNextActiveOptionIfAutoActiveFirstOption();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._componentSetup();\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._triggerElement = null;\n    this._triggerAbortController?.abort();\n    this._openPanelEventsController?.abort();\n  }\n\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n  ): void {\n    super.requestUpdate(name, oldValue, options);\n\n    if (isServer || !this.hasUpdated) {\n      return;\n    }\n    if (!name || name === 'trigger') {\n      this._configureTrigger();\n    } else if ((!name || name === 'origin') && this.isOpen) {\n      this._setOverlayPosition();\n    }\n  }\n\n  /** When an option is selected, update the input value and close the autocomplete. */\n  protected onOptionSelected(event: Event): void {\n    const target = event.target as SbbOptionBaseElement<T>;\n    this._setValueAndDispatchEvents(target);\n    this.close();\n  }\n\n  /**\n   * A 'pending selection' sets the option value in the input element without emitting events.\n   * A 'pending selection' is confirmed when the panel closes. Any other user interaction\n   * will reset the pending value.\n   */\n  protected setPendingSelection(activeOption: SbbOptionBaseElement<T>): void {\n    this.pendingAutoSelectedOption = activeOption;\n    this._setInputValue(activeOption);\n  }\n\n  private _setValueAndDispatchEvents(\n    selectedOption: SbbOptionBaseElement<T>,\n    preventFocus = false,\n  ): void {\n    // Deselect the previous options\n    this.options\n      .filter((option) => option !== selectedOption && option.selected)\n      .forEach((option) => (option.selected = false));\n    this.pendingAutoSelectedOption = null;\n\n    if (this.triggerElement) {\n      this._setInputValue(selectedOption);\n\n      // Manually trigger the change events\n      this._isCustomChangeEvent = true;\n      this.triggerElement.dispatchEvent(new Event('change', { bubbles: true }));\n      this.triggerElement.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n\n      // Dispatching the input event changes _lastInput, which should stay empty since there's no keyboard interaction.\n      this._lastUserInput = null;\n\n      // Custom input event emitted when input value changes after an option is selected\n      this.triggerElement.dispatchEvent(new SbbInputAutocompleteEvent(selectedOption));\n      if (!preventFocus) {\n        this.triggerElement.focus();\n      }\n    }\n  }\n\n  /** Set the option value within the input element */\n  private _setInputValue(option: SbbOptionBaseElement<T>): void {\n    if (!this.triggerElement) {\n      return;\n    }\n\n    // Given a value, returns the string that should be shown within the input.\n    const toDisplay = this.displayWith?.(option.value as T) ?? option.value;\n\n    // Set the option value\n    // In order to support React onChange event, we have to get the setter and call it.\n    // https://github.com/facebook/react/issues/11600#issuecomment-345813130\n    const setValue = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!;\n    setValue.call(this.triggerElement, toDisplay);\n  }\n\n  private _handleSlotchange(): void {\n    this._highlightOptions(this.triggerElement?.value);\n\n    // It is possible that an element is added that has not been rendered\n    // yet and therefore has height 0. Therefore, we also observe the size\n    // of all child elements.\n    const currentElements = Array.from(this.querySelectorAll('*'));\n    this._previousElements?.forEach((e) => this._resizeObserver.unobserve(e));\n    this._previousElements = currentElements;\n    this._previousElements.forEach((e) => this._resizeObserver.observe(e));\n\n    /**\n     * It's possible to filter out options with an opened panel on input change.\n     * In this case, the panel's position must be recalculated considering the new option's list.\n     */\n    if (this.isOpen) {\n      this._setOverlayPosition();\n      this._setNextActiveOptionIfAutoActiveFirstOption();\n\n      // If the autocomplete is open and the option count gets to zero, we close the autocomplete.\n      if (this._optionsCount > 0 && this.options.length === 0) {\n        this.close();\n      }\n    } else if (\n      // If the 'input' is focused and the count of options changes from 0 to > 0,\n      // the autocomplete should open automatically.\n      document?.activeElement === this.triggerElement &&\n      this._optionsCount === 0 &&\n      this.options.length > 0\n    ) {\n      this.open();\n    }\n\n    this._optionsCount = this.options.length;\n  }\n\n  private _setNextActiveOptionIfAutoActiveFirstOption(): void {\n    if (this.autoActiveFirstOption) {\n      this.resetActiveElement();\n      this.setNextActiveOption();\n    }\n  }\n\n  /** The autocomplete should inherit 'readonly' state from the trigger. */\n  private _readonly(): boolean {\n    return this.triggerElement?.hasAttribute('readonly') ?? false;\n  }\n\n  private _componentSetup(): void {\n    if (isServer) {\n      return;\n    }\n\n    this._configureTrigger();\n  }\n\n  private _configureTrigger(): void {\n    const triggerElement = (this.trigger ??\n      this.closest?.('sbb-form-field')?.querySelector('input')) as HTMLInputElement | null;\n    if (triggerElement === this.triggerElement) {\n      return;\n    }\n\n    this._triggerAbortController?.abort();\n    removeAriaComboBoxAttributes(this.triggerElement);\n    this.triggerElement?.removeAttribute('data-expanded');\n    this._triggerElement = triggerElement;\n\n    if (!this.triggerElement) {\n      return;\n    }\n\n    // As the trigger can be the fallback of the origin, we eventually have to update the position.\n    const originElement = this.originElement;\n    if (this.triggerElement === originElement && this.isOpen) {\n      this._setOverlayPosition(originElement);\n    }\n\n    this._triggerAttributeObserver?.observe(this.triggerElement!, {\n      attributes: true,\n      attributeFilter: ['disabled', 'readonly'],\n    });\n\n    this.setTriggerAttributes(this.triggerElement);\n    this._triggerAbortController = new AbortController();\n\n    // Open the overlay on focus, click, input and `ArrowDown` event\n    this.triggerElement.addEventListener('focus', () => this.open(), {\n      signal: this._triggerAbortController.signal,\n    });\n    this.triggerElement.addEventListener('click', () => this.open(), {\n      signal: this._triggerAbortController.signal,\n    });\n    this.triggerElement.addEventListener(\n      'input',\n      (event) => {\n        const value: string = (event.target as HTMLInputElement).value;\n\n        // Do not open if the event is triggered via dispatchEvent (e.g. click on timetable-swap-button)\n        if (value && event.isTrusted) {\n          this.open();\n        }\n        this._highlightOptions(value);\n        this._lastUserInput = value;\n        this.pendingAutoSelectedOption = null;\n      },\n      { signal: this._triggerAbortController.signal },\n    );\n    this.triggerElement.addEventListener(\n      'change',\n      (event) => {\n        /**\n         * In 'requireSelection' mode, we block the native change events and\n         * let only pass the ones that come with a valid value (when an option is selected)\n         */\n        if (this.requireSelection && !this._isCustomChangeEvent) {\n          event.stopImmediatePropagation();\n        }\n        this._isCustomChangeEvent = false;\n      },\n      { signal: this._triggerAbortController.signal, capture: true },\n    );\n    this.triggerElement.addEventListener(\n      'keydown',\n      (event: KeyboardEvent) => this._closedPanelKeyboardInteraction(event),\n      {\n        signal: this._triggerAbortController.signal,\n        // We need key event to run before any other subscription to guarantee a correct\n        // interaction with other components (necessary for the 'sbb-chip-group' use case).\n        capture: true,\n      },\n    );\n\n    this.triggerElement.addEventListener(\n      'blur',\n      (e) => {\n        // If the new focus is the autocomplete or inside of it then an option\n        // was selected. Therefore, the focus is still on the component.\n        if (this.contains(e.relatedTarget as Node)) {\n          return;\n        }\n\n        // If 'autoSelectActiveOptionOnBlur' is enabled, select the active option on blur\n        if (\n          this.autoSelectActiveOptionOnBlur &&\n          this.activeOption &&\n          this._lastUserInput &&\n          this.triggerElement?.value\n        ) {\n          this.activeOption.selected = true;\n          this._setValueAndDispatchEvents(this.activeOption, true);\n        }\n\n        // Clears the input if there's user interaction without selection (selection clears `_lastUserInput`).\n        // A \"pending selection\" is considered a user interaction.\n        if (\n          this.requireSelection &&\n          this.triggerElement &&\n          this._lastUserInput != null &&\n          !this.pendingAutoSelectedOption\n        ) {\n          const setValue = Object.getOwnPropertyDescriptor(\n            HTMLInputElement.prototype,\n            'value',\n          )!.set!;\n          setValue.call(this.triggerElement, '');\n          this._highlightOptions('');\n          this._isCustomChangeEvent = true;\n          this.triggerElement.dispatchEvent(new Event('change', { bubbles: true }));\n          this.triggerElement.dispatchEvent(\n            new InputEvent('input', { bubbles: true, composed: true }),\n          );\n        }\n\n        this.close();\n      },\n      { signal: this._triggerAbortController.signal, capture: true },\n    );\n  }\n\n  // Set overlay position, width and max height\n  private _setOverlayPosition(originElement = this.originElement): void {\n    // An undefined originElement should only occur in the unlikely event\n    // that the autocomplete loses its originElement and triggerElement during an open state.\n    if (!originElement) {\n      return;\n    }\n    setOverlayPosition(\n      this._overlay,\n      originElement,\n      this._overlay,\n      this.shadowRoot!.querySelector('.sbb-option-panel__overlay-container')!,\n      this,\n      this.position,\n    );\n  }\n\n  /**\n   * On open/close animation end.\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   */\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    if (this.originElement) {\n      this._resizeObserver.observe(this.originElement);\n    }\n    this.triggerElement?.setAttribute('aria-expanded', 'true');\n    this.dispatchOpenEvent();\n  }\n\n  private _handleClosing(): void {\n    this.state = 'closed';\n    this.hidePopover?.();\n    this.triggerElement?.setAttribute('aria-expanded', 'false');\n\n    this.resetActiveElement();\n    this._overlay.scrollTop = 0;\n    this._escapableOverlayController.disconnect();\n    this.dispatchCloseEvent();\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 autocomplete 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    this.addEventListener(\n      'ɵdisabledchange',\n      () => {\n        if (this.activeOption?.disabled) {\n          this.resetActiveElement();\n        }\n        this._setNextActiveOptionIfAutoActiveFirstOption();\n      },\n      {\n        signal: this._openPanelEventsController.signal,\n      },\n    );\n\n    // Keyboard interactions\n    this.triggerElement?.addEventListener(\n      'keydown',\n      (event: KeyboardEvent) => this.openedPanelKeyboardInteraction(event),\n      {\n        signal: this._openPanelEventsController.signal,\n        // We need key event to run before any other subscription to guarantee a correct\n        // interaction with other components (necessary for the 'sbb-chip-group' use case).\n        capture: true,\n      },\n    );\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  // If the click is outside the autocomplete, closes the panel.\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 _closedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (this.state === 'opening' || this.state === 'opened') {\n      return;\n    }\n\n    switch (event.key) {\n      case 'ArrowDown':\n      case 'ArrowUp':\n        this.open();\n        break;\n    }\n  }\n\n  /** Highlight the searched text on the options. */\n  private _highlightOptions(searchTerm?: string): void {\n    if (searchTerm === null || searchTerm === undefined) {\n      return;\n    }\n    this.options.forEach((option) => option.highlight(searchTerm));\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-autocomplete__options gets focus.\n    // As elements inside the panel should never get focus, we have to avoid that by setting tabindex=-1.\n    return html`\n      <div class=\"sbb-option-panel__overlay-container\">\n        <div\n          class=\"sbb-option-panel__overlay ${this.negative\n            ? 'sbb-scrollbar-negative'\n            : 'sbb-scrollbar'}\"\n          role=${!ariaRoleOnHost ? this.panelRole : nothing}\n          id=${!ariaRoleOnHost ? this.overlayId : nothing}\n          tabindex=\"-1\"\n          @animationend=${this._onAnimationEnd}\n          ${ref((overlayRef?: Element) => (this._overlay = overlayRef as HTMLElement))}\n        >\n          <slot @slotchange=${this._handleSlotchange}></slot>\n        </div>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementEventMap {\n    inputAutocomplete: SbbInputAutocompleteEvent<any>;\n  }\n}\n"],"mappings":"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"}