@sbb-esta/lyne-elements-dev 4.7.0-dev.1773648103 → 4.7.0-dev.1773648656

package/development/autocomplete/autocomplete.component.js

@@ -1,75 +1,85 @@
-import { getNextElementIndex } from "../core/a11y.js";
+import { t as SbbAutocompleteBaseElement } from "../autocomplete-base-element-DCfmuVY6.js";
 import { isSafari } from "../core/dom.js";
 import { setAriaComboBoxAttributes } from "../core/overlay.js";
-import { SbbAutocompleteBaseElement } from "./autocomplete-base-element.js";
-let nextId = 0;
-const ariaRoleOnHost = isSafari;
-const _SbbAutocompleteElement = class _SbbAutocompleteElement extends SbbAutocompleteBaseElement {
-  constructor() {
-    super(...arguments);
-    this.overlayId = `sbb-autocomplete-${++nextId}`;
-    this.panelRole = "listbox";
-  }
-  get options() {
-    return Array.from(this.querySelectorAll?.("sbb-option") ?? []);
-  }
-  syncNegative() {
-    this.querySelectorAll?.("sbb-divider, sbb-option-hint").forEach((el) => el.negative = this.negative);
-  }
-  openedPanelKeyboardInteraction(event) {
-    if (!this.isOpen) {
-      return;
-    }
-    switch (event.key) {
-      case "Enter":
-        this.selectByKeyboard(event);
-        break;
-      case "ArrowDown":
-      case "ArrowUp":
-        this.setNextActiveOption(event);
-        break;
-    }
-  }
-  selectByKeyboard(event) {
-    if (this.activeOption) {
-      event.preventDefault();
-      this.activeOption["selectViaUserInteraction"](true);
-    }
-  }
-  setNextActiveOption(event) {
-    const enabledOptions = this.options.filter((opt) => !opt.matches(":is(:state(disabled),[state--disabled])"));
-    this.activeOption?.setActive(false);
-    this.triggerElement?.removeAttribute("aria-activedescendant");
-    if (!enabledOptions.length) {
-      this.activeOption = null;
-      return;
-    }
-    const activeItemIndex = this.activeOption ? enabledOptions.indexOf(this.activeOption) : -1;
-    const next = getNextElementIndex(event, activeItemIndex, enabledOptions.length);
-    this.activeOption = enabledOptions[next];
-    this.activeOption.setActive(true);
-    this.triggerElement?.setAttribute("aria-activedescendant", this.activeOption.id);
-    this.activeOption.scrollIntoView({ block: "nearest" });
-    if (event) {
-      event.preventDefault();
-    }
-    if (this.autoSelectActiveOption && event) {
-      this.setPendingSelection(this.activeOption);
-    }
-  }
-  resetActiveElement() {
-    this.activeOption?.setActive(false);
-    this.triggerElement?.removeAttribute("aria-activedescendant");
-    this.activeOption = null;
-  }
-  setTriggerAttributes(element) {
-    setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false);
-  }
-};
-_SbbAutocompleteElement.elementName = "sbb-autocomplete";
-_SbbAutocompleteElement.role = ariaRoleOnHost ? "listbox" : null;
-let SbbAutocompleteElement = _SbbAutocompleteElement;
-export {
-  SbbAutocompleteElement
+import { getNextElementIndex } from "../core/a11y.js";
+//#region src/elements/autocomplete/autocomplete.component.ts
+var nextId = 0;
+/**
+* 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;
+/**
+* Combined with a native input, it displays a panel with a list of available options.
+*
+* @slot - Use the unnamed slot to add `sbb-option` or `sbb-optgroup` elements to the `sbb-autocomplete`.
+* @cssprop [--sbb-autocomplete-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+* the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+* component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+* @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.
+* If the calculated remaining space is smaller, the value gets ignored.
+*/
+var SbbAutocompleteElement = class extends SbbAutocompleteBaseElement {
+	constructor() {
+		super(...arguments);
+		this.overlayId = `sbb-autocomplete-${++nextId}`;
+		this.panelRole = "listbox";
+	}
+	static {
+		this.elementName = "sbb-autocomplete";
+	}
+	static {
+		this.role = ariaRoleOnHost ? "listbox" : null;
+	}
+	get options() {
+		return Array.from(this.querySelectorAll?.("sbb-option") ?? []);
+	}
+	syncNegative() {
+		this.querySelectorAll?.("sbb-divider, sbb-option-hint").forEach((el) => el.negative = this.negative);
+	}
+	openedPanelKeyboardInteraction(event) {
+		if (!this.isOpen) return;
+		switch (event.key) {
+			case "Enter":
+				this.selectByKeyboard(event);
+				break;
+			case "ArrowDown":
+			case "ArrowUp":
+				this.setNextActiveOption(event);
+				break;
+		}
+	}
+	selectByKeyboard(event) {
+		if (this.activeOption) {
+			event.preventDefault();
+			this.activeOption["selectViaUserInteraction"](true);
+		}
+	}
+	setNextActiveOption(event) {
+		const enabledOptions = this.options.filter((opt) => !opt.matches(":is(:state(disabled),[state--disabled])"));
+		this.activeOption?.setActive(false);
+		this.triggerElement?.removeAttribute("aria-activedescendant");
+		if (!enabledOptions.length) {
+			this.activeOption = null;
+			return;
+		}
+		this.activeOption = enabledOptions[getNextElementIndex(event, this.activeOption ? enabledOptions.indexOf(this.activeOption) : -1, enabledOptions.length)];
+		this.activeOption.setActive(true);
+		this.triggerElement?.setAttribute("aria-activedescendant", this.activeOption.id);
+		this.activeOption.scrollIntoView({ block: "nearest" });
+		if (event) event.preventDefault();
+		if (this.autoSelectActiveOption && event) this.setPendingSelection(this.activeOption);
+	}
+	resetActiveElement() {
+		this.activeOption?.setActive(false);
+		this.triggerElement?.removeAttribute("aria-activedescendant");
+		this.activeOption = null;
+	}
+	setTriggerAttributes(element) {
+		setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false);
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"autocomplete.component.js","sources":["../../../../src/elements/autocomplete/autocomplete.component.ts"],"sourcesContent":["import { getNextElementIndex } from '../core/a11y.ts';\nimport { isSafari } from '../core/dom.ts';\nimport { setAriaComboBoxAttributes } from '../core/overlay.ts';\nimport type { SbbDividerElement } from '../divider/divider.component.ts';\nimport type { SbbOptionElement, SbbOptionHintElement } from '../option.ts';\n\nimport { SbbAutocompleteBaseElement } from './autocomplete-base-element.ts';\n\nlet nextId = 0;\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\n/**\n * Combined with a native input, it displays a panel with a list of available options.\n *\n * @slot - Use the unnamed slot to add `sbb-option` or `sbb-optgroup` elements to the `sbb-autocomplete`.\n * @cssprop [--sbb-autocomplete-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 */\nexport class SbbAutocompleteElement<T = string> extends SbbAutocompleteBaseElement<T> {\n  public static override readonly elementName: string = 'sbb-autocomplete';\n  public static override readonly role = ariaRoleOnHost ? 'listbox' : null;\n  protected overlayId = `sbb-autocomplete-${++nextId}`;\n  protected panelRole = 'listbox';\n\n  protected get options(): SbbOptionElement<T>[] {\n    return Array.from(this.querySelectorAll?.<SbbOptionElement<T>>('sbb-option') ?? []);\n  }\n\n  protected syncNegative(): void {\n    this.querySelectorAll?.<SbbDividerElement | SbbOptionHintElement>(\n      'sbb-divider, sbb-option-hint',\n    ).forEach((el) => (el.negative = this.negative));\n  }\n\n  protected openedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (!this.isOpen) {\n      return;\n    }\n    switch (event.key) {\n      case 'Enter':\n        this.selectByKeyboard(event);\n        break;\n\n      case 'ArrowDown':\n      case 'ArrowUp':\n        this.setNextActiveOption(event);\n        break;\n    }\n  }\n\n  protected selectByKeyboard(event: KeyboardEvent): void {\n    if (this.activeOption) {\n      // We are currently selecting an option and therefore the Enter press shouldn't trigger a form submit\n      event.preventDefault();\n\n      this.activeOption['selectViaUserInteraction'](true);\n    }\n  }\n\n  protected setNextActiveOption(event?: KeyboardEvent): void {\n    const enabledOptions = this.options.filter((opt) => !opt.matches(':state(disabled)'));\n\n    // Reset potentially active option\n    this.activeOption?.setActive(false);\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n\n    if (!enabledOptions.length) {\n      this.activeOption = null;\n      return;\n    }\n\n    const activeItemIndex = this.activeOption\n      ? enabledOptions.indexOf(this.activeOption as SbbOptionElement<T>)\n      : -1;\n\n    // Get and activate the next active option\n    const next = getNextElementIndex(event, activeItemIndex, enabledOptions.length);\n    this.activeOption = enabledOptions[next];\n    this.activeOption.setActive(true);\n    this.triggerElement?.setAttribute('aria-activedescendant', this.activeOption.id);\n    this.activeOption.scrollIntoView({ block: 'nearest' });\n\n    // Moving the active option should not move the input cursor (caret)\n    if (event) {\n      event.preventDefault();\n    }\n\n    // If 'autoSelectActiveOption' and is triggered from a keyboard event\n    if (this.autoSelectActiveOption && event) {\n      this.setPendingSelection(this.activeOption);\n    }\n  }\n\n  protected resetActiveElement(): void {\n    this.activeOption?.setActive(false);\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n    this.activeOption = null;\n  }\n\n  protected setTriggerAttributes(element: HTMLInputElement): void {\n    setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false);\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-autocomplete': SbbAutocompleteElement;\n  }\n}\n"],"names":[],"mappings":";;;;AAQA,IAAI,SAAS;AAMb,MAAM,iBAAiB;AAYjB,MAAO,0BAAP,MAAO,gCAA2C,2BAA6B;AAAA,EAArF,cAAA;;AAGY,SAAA,YAAY,oBAAoB,EAAE,MAAM;AACxC,SAAA,YAAY;AAAA,EAgFxB;AAAA,EA9EE,IAAc,UAAO;AACnB,WAAO,MAAM,KAAK,KAAK,mBAAwC,YAAY,KAAK,EAAE;AAAA,EACpF;AAAA,EAEU,eAAY;AACpB,SAAK,mBACH,8BAA8B,EAC9B,QAAQ,CAAC,OAAQ,GAAG,WAAW,KAAK,QAAS;AAAA,EACjD;AAAA,EAEU,+BAA+B,OAAoB;AAC3D,QAAI,CAAC,KAAK,QAAQ;AAChB;AAAA,IACF;AACA,YAAQ,MAAM,KAAA;AAAA,MACZ,KAAK;AACH,aAAK,iBAAiB,KAAK;AAC3B;AAAA,MAEF,KAAK;AAAA,MACL,KAAK;AACH,aAAK,oBAAoB,KAAK;AAC9B;AAAA,IAAA;AAAA,EAEN;AAAA,EAEU,iBAAiB,OAAoB;AAC7C,QAAI,KAAK,cAAc;AAErB,YAAM,eAAA;AAEN,WAAK,aAAa,0BAA0B,EAAE,IAAI;AAAA,IACpD;AAAA,EACF;AAAA,EAEU,oBAAoB,OAAqB;AACjD,UAAM,iBAAiB,KAAK,QAAQ,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,yCAAkB,CAAC;AAGpF,SAAK,cAAc,UAAU,KAAK;AAClC,SAAK,gBAAgB,gBAAgB,uBAAuB;AAE5D,QAAI,CAAC,eAAe,QAAQ;AAC1B,WAAK,eAAe;AACpB;AAAA,IACF;AAEA,UAAM,kBAAkB,KAAK,eACzB,eAAe,QAAQ,KAAK,YAAmC,IAC/D;AAGJ,UAAM,OAAO,oBAAoB,OAAO,iBAAiB,eAAe,MAAM;AAC9E,SAAK,eAAe,eAAe,IAAI;AACvC,SAAK,aAAa,UAAU,IAAI;AAChC,SAAK,gBAAgB,aAAa,yBAAyB,KAAK,aAAa,EAAE;AAC/E,SAAK,aAAa,eAAe,EAAE,OAAO,WAAW;AAGrD,QAAI,OAAO;AACT,YAAM,eAAA;AAAA,IACR;AAGA,QAAI,KAAK,0BAA0B,OAAO;AACxC,WAAK,oBAAoB,KAAK,YAAY;AAAA,IAC5C;AAAA,EACF;AAAA,EAEU,qBAAkB;AAC1B,SAAK,cAAc,UAAU,KAAK;AAClC,SAAK,gBAAgB,gBAAgB,uBAAuB;AAC5D,SAAK,eAAe;AAAA,EACtB;AAAA,EAEU,qBAAqB,SAAyB;AACtD,8BAA0B,SAAS,iBAAiB,KAAK,KAAK,KAAK,WAAW,KAAK;AAAA,EACrF;;AAlFgC,wBAAA,cAAsB;AACtB,wBAAA,OAAO,iBAAiB,YAAY;AAFhE,IAAO,yBAAP;"}
+//#endregion
+export { SbbAutocompleteElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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