@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/option/option.js

@@ -0,0 +1,444 @@
+import { css, LitElement, html, nothing } from "lit";
+import { property, state, customElement } from "lit/decorators.js";
+import { SbbConnectedAbortController, SbbSlotStateController } from "../core/controllers.js";
+import { hostAttributes } from "../core/decorators.js";
+import { setOrRemoveAttribute, isAndroid, isSafari } from "../core/dom.js";
+import { EventEmitter } from "../core/eventing.js";
+import { SbbDisabledMixin } from "../core/mixins.js";
+import { AgnosticMutationObserver } from "../core/observers.js";
+import { SbbIconNameMixin } from "../icon.js";
+import "../screen-reader-only.js";
+import "../visual-checkbox.js";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-option-color: var(--sbb-color-charcoal);
+  --sbb-option-background-color: inherit;
+  --sbb-option-background-color-hover: var(--sbb-color-milk);
+  --sbb-option-background-color-active: var(--sbb-color-cloud);
+  --sbb-option-disabled-border-color: var(--sbb-color-graphite);
+  --sbb-option-disabled-background-color: var(--sbb-color-milk);
+  --sbb-option-padding-inline: var(--sbb-spacing-responsive-xxxs);
+  --sbb-option-padding-block: calc(var(--sbb-spacing-fixed-2x) + var(--sbb-border-width-2x));
+  --sbb-option-column-gap: var(--sbb-spacing-responsive-xxxs);
+  --sbb-option-justify-content: start;
+  --sbb-option-cursor: pointer;
+  --sbb-option-border-radius: var(--sbb-border-radius-4x);
+  --sbb-option-icon-color: var(--sbb-color-metal);
+  display: block;
+}
+
+:host([data-negative]) {
+  --sbb-option-color: var(--sbb-color-milk);
+  --sbb-option-icon-color: var(--sbb-color-smoke);
+  --sbb-option-background-color-hover: var(--sbb-color-charcoal);
+  --sbb-option-background-color-active: var(--sbb-color-iron);
+  --sbb-option-disabled-border-color: var(--sbb-color-smoke);
+  --sbb-option-disabled-background-color: var(--sbb-color-charcoal);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+}
+
+:host([active]) {
+  --sbb-focus-outline-offset: calc(-1 * var(--sbb-spacing-fixed-1x));
+}
+
+@media (any-hover: hover) {
+  :host(:hover:not([disabled], [data-group-disabled])) {
+    --sbb-option-background-color: var(--sbb-option-background-color-hover);
+  }
+}
+
+:host(:active:not([disabled], [data-group-disabled])) {
+  --sbb-option-background-color: var(--sbb-option-background-color-active);
+}
+
+:host(:not([data-disable-highlight])) .sbb-option__label slot {
+  display: none;
+}
+
+:host(:is([data-group-disabled], [disabled])) {
+  --sbb-option-cursor: default;
+}
+@media (forced-colors: active) {
+  :host(:is([data-group-disabled], [disabled])) {
+    --sbb-option-color: GrayText;
+  }
+}
+
+:host([data-variant=select]) {
+  --sbb-option-column-gap: var(--sbb-spacing-fixed-2x);
+  --sbb-option-justify-content: space-between;
+}
+
+:host([data-variant=select][data-multiple]) {
+  --sbb-option-justify-content: start;
+}
+
+:host(:not(:is([disabled], [data-group-disabled]))) .sbb-option__label--highlight {
+  font-weight: bold;
+}
+@media (forced-colors: active) {
+  :host(:not(:is([disabled], [data-group-disabled]))) .sbb-option__label--highlight {
+    color: Highlight;
+  }
+}
+
+.sbb-option__container {
+  background-color: var(--sbb-option-background-color);
+}
+
+.sbb-option {
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  display: flex;
+  align-items: center;
+  column-gap: var(--sbb-option-column-gap);
+  padding-inline: var(--sbb-option-padding-inline);
+  padding-block: var(--sbb-option-padding-block);
+  justify-content: var(--sbb-option-justify-content);
+  color: var(--sbb-option-color);
+  background-color: var(--sbb-option-background-color);
+  cursor: var(--sbb-option-cursor);
+  -webkit-tap-highlight-color: transparent;
+  -webkit-text-fill-color: var(--sbb-option-color);
+}
+:host([active]) .sbb-option {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) solid var(--sbb-focus-outline-width);
+  border-radius: var(--sbb-option-border-radius);
+}
+:host(:is([data-group-disabled], [disabled]):not([data-multiple])) .sbb-option {
+  position: relative;
+  z-index: 0;
+}
+:host(:is([data-group-disabled], [disabled]):not([data-multiple])) .sbb-option::before {
+  content: "";
+  display: block;
+  position: absolute;
+  inset: 0.375rem;
+  border: var(--sbb-border-width-1x) dashed var(--sbb-option-disabled-border-color);
+  border-radius: var(--sbb-border-radius-2x);
+  background-color: var(--sbb-option-disabled-background-color);
+  z-index: -1;
+}
+@media (forced-colors: active) {
+  :host(:is([data-group-disabled], [disabled]):not([data-multiple])) .sbb-option::before {
+    border-color: GrayText;
+  }
+}
+
+.sbb-option__icon {
+  display: flex;
+  min-width: var(--sbb-size-icon-ui-small);
+  min-height: var(--sbb-size-icon-ui-small);
+  color: var(--sbb-option-icon-color);
+}
+:host(:not([data-slot-names~=icon], [icon-name])) .sbb-option__icon {
+  display: var(--sbb-option-icon-container-display, none);
+}
+
+.sbb-option__label {
+  white-space: initial;
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+const inertAriaGroups = isSafari;
+let nextId = 0;
+const optionObserverConfig = {
+  attributeFilter: ["data-group-disabled", "data-negative"]
+};
+let SbbOptionElement = class extends SbbDisabledMixin(SbbIconNameMixin(LitElement)) {
+  constructor() {
+    super();
+    this._selectionChange = new EventEmitter(
+      this,
+      SbbOptionElement.events.selectionChange
+    );
+    this._optionSelected = new EventEmitter(
+      this,
+      SbbOptionElement.events.optionSelected
+    );
+    this._negative = false;
+    this._disabledFromGroup = false;
+    this._highlightString = null;
+    this._disableLabelHighlight = false;
+    this._abort = new SbbConnectedAbortController(this);
+    this._optionAttributeObserver = new AgnosticMutationObserver(
+      (mutationsList) => this._onOptionAttributesChange(mutationsList)
+    );
+    new SbbSlotStateController(this);
+  }
+  set value(value) {
+    this.setAttribute("value", `${value}`);
+  }
+  get value() {
+    return this.getAttribute("value") ?? "";
+  }
+  set selected(value) {
+    this.toggleAttribute("selected", value);
+    this._updateAriaSelected();
+  }
+  get selected() {
+    return this.hasAttribute("selected");
+  }
+  set _variant(state2) {
+    this.setAttribute("data-variant", state2);
+  }
+  get _variant() {
+    return this.getAttribute("data-variant");
+  }
+  get _isAutocomplete() {
+    return this._variant === "autocomplete";
+  }
+  get _isSelect() {
+    return this._variant === "select";
+  }
+  get _isMultiple() {
+    var _a;
+    return !!((_a = this.closest) == null ? void 0 : _a.call(this, "sbb-select[multiple]"));
+  }
+  attributeChangedCallback(name, old, value) {
+    if (name !== "value" || old !== value) {
+      super.attributeChangedCallback(name, old, value);
+    }
+  }
+  /**
+   * Highlight the label of the option
+   * @param value the highlighted portion of the label
+   * @internal
+   */
+  highlight(value) {
+    this._highlightString = value;
+  }
+  /**
+   * @internal
+   */
+  setSelectedViaUserInteraction(selected) {
+    this.selected = selected;
+    this._selectionChange.emit();
+    if (this.selected) {
+      this._optionSelected.emit();
+    }
+  }
+  _updateDisableHighlight(disabled) {
+    this._disableLabelHighlight = disabled;
+    this.toggleAttribute("data-disable-highlight", disabled);
+  }
+  _selectByClick(event) {
+    if (this.disabled || this._disabledFromGroup) {
+      event.stopPropagation();
+      return;
+    }
+    if (this._isMultiple) {
+      event.stopPropagation();
+      this.setSelectedViaUserInteraction(!this.selected);
+    } else {
+      this.setSelectedViaUserInteraction(true);
+    }
+  }
+  connectedCallback() {
+    var _a, _b;
+    super.connectedCallback();
+    this.id || (this.id = `sbb-option-${nextId++}`);
+    const signal = this._abort.signal;
+    const parentGroup = (_a = this.closest) == null ? void 0 : _a.call(this, "sbb-optgroup");
+    if (parentGroup) {
+      this._disabledFromGroup = parentGroup.disabled;
+      this._updateAriaDisabled();
+    }
+    this._optionAttributeObserver.observe(this, optionObserverConfig);
+    this._negative = !!((_b = this.closest) == null ? void 0 : _b.call(
+      this,
+      // :is() selector not possible due to test environment
+      `sbb-autocomplete[negative],sbb-select[negative],sbb-form-field[negative]`
+    ));
+    this.toggleAttribute("data-negative", this._negative);
+    this._setVariantByContext();
+    this._handleHighlightState();
+    this.toggleAttribute("data-multiple", this._isMultiple);
+    this.addEventListener("click", (e) => this._selectByClick(e), {
+      signal,
+      passive: true
+    });
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("disabled")) {
+      setOrRemoveAttribute(this, "tabindex", isAndroid && !this.disabled && 0);
+      this._updateAriaDisabled();
+    }
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    this._updateAriaSelected();
+  }
+  _updateAriaDisabled() {
+    setOrRemoveAttribute(
+      this,
+      "aria-disabled",
+      this.disabled || this._disabledFromGroup ? "true" : null
+    );
+  }
+  _updateAriaSelected() {
+    this.setAttribute("aria-selected", `${this.selected}`);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._optionAttributeObserver.disconnect();
+  }
+  _setVariantByContext() {
+    var _a, _b;
+    if ((_a = this.closest) == null ? void 0 : _a.call(this, "sbb-autocomplete")) {
+      this._variant = "autocomplete";
+    } else if ((_b = this.closest) == null ? void 0 : _b.call(this, "sbb-select")) {
+      this._variant = "select";
+    }
+  }
+  /** Observe changes on data attributes and set the appropriate values. */
+  _onOptionAttributesChange(mutationsList) {
+    for (const mutation of mutationsList) {
+      if (mutation.attributeName === "data-group-disabled") {
+        this._disabledFromGroup = this.hasAttribute("data-group-disabled");
+        this._updateAriaDisabled();
+      } else if (mutation.attributeName === "data-negative") {
+        this._negative = this.hasAttribute("data-negative");
+      }
+    }
+  }
+  _handleHighlightState() {
+    if (!this._isAutocomplete) {
+      this._updateDisableHighlight(true);
+      return;
+    }
+    const slotNodes = Array.from(this.childNodes ?? []).filter(
+      (n) => !(n instanceof Element) || n.slot !== "icon"
+    );
+    const labelNodes = slotNodes.filter((el) => el.nodeType === Node.TEXT_NODE);
+    if (labelNodes.length === 0 || slotNodes.filter((n) => !(n instanceof Element) || n.localName !== "template").length !== labelNodes.length) {
+      this._updateDisableHighlight(true);
+      return;
+    }
+    this._label = labelNodes.map((l) => l.wholeText).filter((l) => l.trim()).join();
+  }
+  _getHighlightedLabel() {
+    if (!this._highlightString || !this._highlightString.trim()) {
+      return html`${this._label}`;
+    }
+    const matchIndex = this._label.toLowerCase().indexOf(this._highlightString.toLowerCase());
+    if (matchIndex === -1) {
+      return html`${this._label}`;
+    }
+    const prefix = this._label.substring(0, matchIndex);
+    const highlighted = this._label.substring(
+      matchIndex,
+      matchIndex + this._highlightString.length
+    );
+    const postfix = this._label.substring(matchIndex + this._highlightString.length);
+    return html`
+      <span class="sbb-option__label--highlight">${prefix}</span><span>${highlighted}</span
+      ><span class="sbb-option__label--highlight">${postfix}</span>
+    `;
+  }
+  render() {
+    const isMultiple = this._isMultiple;
+    return html`
+      <div class="sbb-option__container">
+        <div class="sbb-option">
+          <!-- Icon -->
+          ${!isMultiple ? html` <span class="sbb-option__icon"> ${this.renderIconSlot()} </span>` : nothing}
+
+          <!-- Checkbox -->
+          ${isMultiple ? html` <sbb-visual-checkbox
+                ?checked=${this.selected}
+                ?disabled=${this.disabled || this._disabledFromGroup}
+                ?negative=${this._negative}
+              ></sbb-visual-checkbox>` : nothing}
+
+          <!-- Label -->
+          <span class="sbb-option__label">
+            <slot @slotchange=${this._handleHighlightState}></slot>
+
+            <!-- Search highlight -->
+            ${this._isAutocomplete && this._label && !this._disableLabelHighlight ? this._getHighlightedLabel() : nothing}
+            ${inertAriaGroups && this.getAttribute("data-group-label") ? html` <sbb-screen-reader-only>
+                  (${this.getAttribute("data-group-label")})</sbb-screen-reader-only
+                >` : nothing}
+          </span>
+
+          <!-- Selected tick -->
+          ${this._isSelect && !isMultiple && this.selected ? html`<sbb-icon name="tick-small"></sbb-icon>` : nothing}
+        </div>
+      </div>
+    `;
+  }
+};
+SbbOptionElement.styles = style;
+SbbOptionElement.events = {
+  selectionChange: "optionSelectionChange",
+  optionSelected: "optionSelected"
+};
+__decorateClass([
+  property()
+], SbbOptionElement.prototype, "value", 1);
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbOptionElement.prototype, "active", 2);
+__decorateClass([
+  property({ type: Boolean })
+], SbbOptionElement.prototype, "selected", 1);
+__decorateClass([
+  state()
+], SbbOptionElement.prototype, "_negative", 2);
+__decorateClass([
+  state()
+], SbbOptionElement.prototype, "_disabledFromGroup", 2);
+__decorateClass([
+  state()
+], SbbOptionElement.prototype, "_label", 2);
+__decorateClass([
+  state()
+], SbbOptionElement.prototype, "_highlightString", 2);
+__decorateClass([
+  state()
+], SbbOptionElement.prototype, "_disableLabelHighlight", 2);
+SbbOptionElement = __decorateClass([
+  customElement("sbb-option"),
+  hostAttributes({
+    role: "option"
+  })
+], SbbOptionElement);
+export {
+  SbbOptionElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"option.js","sources":["../../../../src/elements/option/option/option.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  LitElement,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\n\nimport { SbbConnectedAbortController, SbbSlotStateController } from '../../core/controllers.js';\nimport { hostAttributes } from '../../core/decorators.js';\nimport { isAndroid, isSafari, setOrRemoveAttribute } from '../../core/dom.js';\nimport { EventEmitter } from '../../core/eventing.js';\nimport { SbbDisabledMixin } from '../../core/mixins.js';\nimport { AgnosticMutationObserver } from '../../core/observers.js';\nimport { SbbIconNameMixin } from '../../icon.js';\n\nimport style from './option.scss?lit&inline';\n\nimport '../../screen-reader-only.js';\nimport '../../visual-checkbox.js';\n\n/**\n * On Safari, the groups labels are not read by VoiceOver.\n * To solve the problem, we remove the role=\"group\" and add an hidden span containing the group name\n * TODO: We should periodically check if it has been solved and, if so, remove the property.\n */\nconst inertAriaGroups = isSafari;\n\nlet nextId = 0;\n\n/** Configuration for the attribute to look at if component is nested in a sbb-checkbox-group */\nconst optionObserverConfig: MutationObserverInit = {\n  attributeFilter: ['data-group-disabled', 'data-negative'],\n};\n\nexport type SbbOptionVariant = 'autocomplete' | 'select';\n\n/**\n * It displays on option item which can be used in `sbb-select` or `sbb-autocomplete`.\n *\n * @slot - Use the unnamed slot to add content to the option label.\n * @slot icon - Use this slot to provide an icon. If `icon-name` is set, a sbb-icon will be used.\n * @event {CustomEvent<void>} optionSelectionChange - Emits when the option selection status changes.\n * @event {CustomEvent<void>} optionSelected - Emits when an option was selected by user.\n * @cssprop [--sbb-option-icon-container-display=none] - Can be used to reserve space even\n * when preserve-icon-space on autocomplete is not set or iconName is not set.\n */\n@customElement('sbb-option')\n@hostAttributes({\n  role: 'option',\n})\nexport class SbbOptionElement extends SbbDisabledMixin(SbbIconNameMixin(LitElement)) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    selectionChange: 'optionSelectionChange',\n    optionSelected: 'optionSelected',\n  } as const;\n\n  /**\n   * Value of the option.\n   *\n   * @description Developer note: In this case updating the attribute must be synchronous.\n   * Due to this it is implemented as a getter/setter and the attributeChangedCallback() handles the diff check.\n   */\n  @property()\n  public set value(value: string) {\n    this.setAttribute('value', `${value}`);\n  }\n  public get value(): string {\n    return this.getAttribute('value') ?? '';\n  }\n\n  /** Whether the option is currently active. */\n  @property({ reflect: true, type: Boolean }) public active?: boolean;\n\n  /** Whether the option is selected. */\n  @property({ type: Boolean })\n  public set selected(value: boolean) {\n    this.toggleAttribute('selected', value);\n    this._updateAriaSelected();\n  }\n  public get selected(): boolean {\n    return this.hasAttribute('selected');\n  }\n\n  /** Emits when the option selection status changes. */\n  private _selectionChange: EventEmitter = new EventEmitter(\n    this,\n    SbbOptionElement.events.selectionChange,\n  );\n\n  /** Emits when an option was selected by user. */\n  private _optionSelected: EventEmitter = new EventEmitter(\n    this,\n    SbbOptionElement.events.optionSelected,\n  );\n\n  /** Whether to apply the negative styling */\n  @state() private _negative = false;\n\n  /** Whether the component must be set disabled due disabled attribute on sbb-checkbox-group. */\n  @state() private _disabledFromGroup = false;\n\n  @state() private _label?: string;\n\n  /** The portion of the highlighted label. */\n  @state() private _highlightString: string | null = null;\n\n  /** Disable the highlight of the label. */\n  @state() private _disableLabelHighlight: boolean = false;\n\n  private set _variant(state: SbbOptionVariant) {\n    this.setAttribute('data-variant', state);\n  }\n  private get _variant(): SbbOptionVariant {\n    return this.getAttribute('data-variant') as SbbOptionVariant;\n  }\n\n  private _abort = new SbbConnectedAbortController(this);\n\n  /** MutationObserver on data attributes. */\n  private _optionAttributeObserver = new AgnosticMutationObserver((mutationsList) =>\n    this._onOptionAttributesChange(mutationsList),\n  );\n\n  private get _isAutocomplete(): boolean {\n    return this._variant === 'autocomplete';\n  }\n\n  private get _isSelect(): boolean {\n    return this._variant === 'select';\n  }\n\n  private get _isMultiple(): boolean {\n    return !!this.closest?.('sbb-select[multiple]');\n  }\n\n  public constructor() {\n    super();\n    new SbbSlotStateController(this);\n  }\n\n  public override attributeChangedCallback(\n    name: string,\n    old: string | null,\n    value: string | null,\n  ): void {\n    if (name !== 'value' || old !== value) {\n      super.attributeChangedCallback(name, old, value);\n    }\n  }\n\n  /**\n   * Highlight the label of the option\n   * @param value the highlighted portion of the label\n   * @internal\n   */\n  public highlight(value: string): void {\n    this._highlightString = value;\n  }\n\n  /**\n   * @internal\n   */\n  public setSelectedViaUserInteraction(selected: boolean): void {\n    this.selected = selected;\n    this._selectionChange.emit();\n    if (this.selected) {\n      this._optionSelected.emit();\n    }\n  }\n\n  private _updateDisableHighlight(disabled: boolean): void {\n    this._disableLabelHighlight = disabled;\n    this.toggleAttribute('data-disable-highlight', disabled);\n  }\n\n  private _selectByClick(event: MouseEvent): void {\n    if (this.disabled || this._disabledFromGroup) {\n      event.stopPropagation();\n      return;\n    }\n\n    if (this._isMultiple) {\n      event.stopPropagation();\n      this.setSelectedViaUserInteraction(!this.selected);\n    } else {\n      this.setSelectedViaUserInteraction(true);\n    }\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    this.id ||= `sbb-option-${nextId++}`;\n\n    const signal = this._abort.signal;\n    const parentGroup = this.closest?.('sbb-optgroup');\n    if (parentGroup) {\n      this._disabledFromGroup = parentGroup.disabled;\n      this._updateAriaDisabled();\n    }\n    this._optionAttributeObserver.observe(this, optionObserverConfig);\n\n    this._negative = !!this.closest?.(\n      // :is() selector not possible due to test environment\n      `sbb-autocomplete[negative],sbb-select[negative],sbb-form-field[negative]`,\n    );\n    this.toggleAttribute('data-negative', this._negative);\n\n    this._setVariantByContext();\n    // We need to check highlight state both on slot change, but also when connecting\n    // the element to the DOM. The slot change events might be swallowed when using declarative\n    // shadow DOM with SSR or if the DOM is changed when disconnected.\n    this._handleHighlightState();\n\n    this.toggleAttribute('data-multiple', this._isMultiple);\n\n    this.addEventListener('click', (e: MouseEvent) => this._selectByClick(e), {\n      signal,\n      passive: true,\n    });\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('disabled')) {\n      setOrRemoveAttribute(this, 'tabindex', isAndroid && !this.disabled && 0);\n      this._updateAriaDisabled();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    // Init first select state because false would not call setter of selected property.\n    this._updateAriaSelected();\n  }\n\n  private _updateAriaDisabled(): void {\n    setOrRemoveAttribute(\n      this,\n      'aria-disabled',\n      this.disabled || this._disabledFromGroup ? 'true' : null,\n    );\n  }\n\n  private _updateAriaSelected(): void {\n    this.setAttribute('aria-selected', `${this.selected}`);\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._optionAttributeObserver.disconnect();\n  }\n\n  private _setVariantByContext(): void {\n    if (this.closest?.('sbb-autocomplete')) {\n      this._variant = 'autocomplete';\n    } else if (this.closest?.('sbb-select')) {\n      this._variant = 'select';\n    }\n  }\n\n  /** Observe changes on data attributes and set the appropriate values. */\n  private _onOptionAttributesChange(mutationsList: MutationRecord[]): void {\n    for (const mutation of mutationsList) {\n      if (mutation.attributeName === 'data-group-disabled') {\n        this._disabledFromGroup = this.hasAttribute('data-group-disabled');\n        this._updateAriaDisabled();\n      } else if (mutation.attributeName === 'data-negative') {\n        this._negative = this.hasAttribute('data-negative');\n      }\n    }\n  }\n\n  private _handleHighlightState(): void {\n    if (!this._isAutocomplete) {\n      this._updateDisableHighlight(true);\n      return;\n    }\n\n    const slotNodes = Array.from(this.childNodes ?? []).filter(\n      (n) => !(n instanceof Element) || n.slot !== 'icon',\n    );\n    const labelNodes = slotNodes.filter((el) => el.nodeType === Node.TEXT_NODE) as Text[];\n\n    // Disable the highlight if the slot contain more than just text nodes.\n    // We need to ignore template elements, as SSR adds a declarative shadow DOM\n    // in the form of a template element.\n    if (\n      labelNodes.length === 0 ||\n      slotNodes.filter((n) => !(n instanceof Element) || n.localName !== 'template').length !==\n        labelNodes.length\n    ) {\n      this._updateDisableHighlight(true);\n      return;\n    }\n    this._label = labelNodes\n      .map((l) => l.wholeText)\n      .filter((l) => l.trim())\n      .join();\n  }\n\n  private _getHighlightedLabel(): TemplateResult {\n    if (!this._highlightString || !this._highlightString.trim()) {\n      return html`${this._label}`;\n    }\n\n    const matchIndex = this._label!.toLowerCase().indexOf(this._highlightString.toLowerCase());\n\n    if (matchIndex === -1) {\n      return html`${this._label}`;\n    }\n\n    const prefix = this._label!.substring(0, matchIndex);\n    const highlighted = this._label!.substring(\n      matchIndex,\n      matchIndex + this._highlightString.length,\n    );\n    const postfix = this._label!.substring(matchIndex + this._highlightString.length);\n\n    return html`\n      <span class=\"sbb-option__label--highlight\">${prefix}</span><span>${highlighted}</span\n      ><span class=\"sbb-option__label--highlight\">${postfix}</span>\n    `;\n  }\n\n  protected override render(): TemplateResult {\n    const isMultiple = this._isMultiple;\n\n    return html`\n      <div class=\"sbb-option__container\">\n        <div class=\"sbb-option\">\n          <!-- Icon -->\n          ${!isMultiple\n            ? html` <span class=\"sbb-option__icon\"> ${this.renderIconSlot()} </span>`\n            : nothing}\n\n          <!-- Checkbox -->\n          ${isMultiple\n            ? html` <sbb-visual-checkbox\n                ?checked=${this.selected}\n                ?disabled=${this.disabled || this._disabledFromGroup}\n                ?negative=${this._negative}\n              ></sbb-visual-checkbox>`\n            : nothing}\n\n          <!-- Label -->\n          <span class=\"sbb-option__label\">\n            <slot @slotchange=${this._handleHighlightState}></slot>\n\n            <!-- Search highlight -->\n            ${this._isAutocomplete && this._label && !this._disableLabelHighlight\n              ? this._getHighlightedLabel()\n              : nothing}\n            ${inertAriaGroups && this.getAttribute('data-group-label')\n              ? html` <sbb-screen-reader-only>\n                  (${this.getAttribute('data-group-label')})</sbb-screen-reader-only\n                >`\n              : nothing}\n          </span>\n\n          <!-- Selected tick -->\n          ${this._isSelect && !isMultiple && this.selected\n            ? html`<sbb-icon name=\"tick-small\"></sbb-icon>`\n            : nothing}\n        </div>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-option': SbbOptionElement;\n  }\n\n  interface GlobalEventHandlersEventMap {\n    optionSelectionChange: CustomEvent<void>;\n  }\n}\n"],"names":["state"],"mappings":"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"}

package/development/option.d.ts

@@ -0,0 +1,3 @@
+export * from './option/optgroup.js';
+export * from './option/option.js';
+//# sourceMappingURL=option.d.ts.map

package/development/option.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.d.ts","sourceRoot":"","sources":["../../../src/elements/option.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}

package/development/option.js

@@ -0,0 +1,3 @@
+export * from "./option/optgroup.js";
+export * from "./option/option.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7In0=

package/development/overlay/overlay-base-element.d.ts

@@ -0,0 +1,43 @@
+import { PropertyValues } from 'lit';
+import { SbbFocusHandler } from '../core/a11y.js';
+import { SbbOpenCloseBaseElement } from '../core/base-elements.js';
+import { SbbLanguageController } from '../core/controllers.js';
+import { SbbScrollHandler } from '../core/dom.js';
+import { EventEmitter } from '../core/eventing.js';
+import { SbbOverlayCloseEventDetails } from '../core/interfaces.js';
+import { SbbScreenReaderOnlyElement } from '../screen-reader-only.js';
+
+export declare const overlayRefs: SbbOverlayBaseElement[];
+declare const SbbOverlayBaseElement_base: import('../core/mixins.js').AbstractConstructor<import('../core/mixins.js').SbbNegativeMixinType> & typeof SbbOpenCloseBaseElement;
+export declare abstract class SbbOverlayBaseElement extends SbbOverlayBaseElement_base {
+    /** This will be forwarded as aria-label to the relevant nested element to describe the purpose of the overlay. */
+    accessibilityLabel: string | undefined;
+    /** Emits whenever the component is closed. */
+    protected didClose: EventEmitter<SbbOverlayCloseEventDetails>;
+    protected lastFocusedElement?: HTMLElement;
+    protected overlayCloseElement?: HTMLElement;
+    protected overlayController: AbortController;
+    protected openOverlayController: AbortController;
+    protected focusHandler: SbbFocusHandler;
+    protected scrollHandler: SbbScrollHandler;
+    protected returnValue: any;
+    protected ariaLiveRefToggle: boolean;
+    protected ariaLiveRef: SbbScreenReaderOnlyElement;
+    protected language: SbbLanguageController;
+    protected abstract onOverlayAnimationEnd(event: AnimationEvent): void;
+    protected abstract setOverlayFocus(): void;
+    protected abstract closeAttribute: string;
+    /** Closes the component. */
+    close(result?: any, target?: HTMLElement): any;
+    connectedCallback(): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    disconnectedCallback(): void;
+    protected attachOpenOverlayEvents(): void;
+    protected onKeydownEvent(event: KeyboardEvent): void;
+    protected removeInstanceFromGlobalCollection(): void;
+    protected closeOnSbbOverlayCloseClick(event: Event): void;
+    protected removeAriaLiveRefContent(): void;
+    protected setAriaLiveRefContent(label?: string): void;
+}
+export {};
+//# sourceMappingURL=overlay-base-element.d.ts.map

package/development/overlay/overlay-base-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-base-element.d.ts","sourceRoot":"","sources":["../../../../src/elements/overlay/overlay-base-element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAG1C,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAe,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAGzE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAG3E,eAAO,MAAM,WAAW,EAAE,qBAAqB,EAAO,CAAC;;AAEvD,8BAAsB,qBAAsB,SAAQ,0BAAyC;IAC3F,kHAAkH;IAC3D,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IAE9F,8CAA8C;IAC9C,UAAmB,QAAQ,EAAE,YAAY,CAAC,2BAA2B,CAAC,CAGpE;IAGF,SAAS,CAAC,kBAAkB,CAAC,EAAE,WAAW,CAAC;IAC3C,SAAS,CAAC,mBAAmB,CAAC,EAAE,WAAW,CAAC;IAC5C,SAAS,CAAC,iBAAiB,EAAG,eAAe,CAAC;IAC9C,SAAS,CAAC,qBAAqB,EAAG,eAAe,CAAC;IAClD,SAAS,CAAC,YAAY,kBAAyB;IAC/C,SAAS,CAAC,aAAa,mBAA0B;IACjD,SAAS,CAAC,WAAW,EAAE,GAAG,CAAC;IAC3B,SAAS,CAAC,iBAAiB,UAAS;IACpC,SAAS,CAAC,WAAW,EAAG,0BAA0B,CAAC;IACnD,SAAS,CAAC,QAAQ,wBAAmC;IAErD,SAAS,CAAC,QAAQ,CAAC,qBAAqB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IACrE,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,IAAI;IAC1C,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAE1C,4BAA4B;IACrB,KAAK,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,GAAG;IAmBrC,iBAAiB,IAAI,IAAI;cAUtB,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAO9D,oBAAoB,IAAI,IAAI;IAS5C,SAAS,CAAC,uBAAuB,IAAI,IAAI;IAkBzC,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAWpD,SAAS,CAAC,kCAAkC,IAAI,IAAI;IAKpD,SAAS,CAAC,2BAA2B,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAoBzD,SAAS,CAAC,wBAAwB,IAAI,IAAI;IAI1C,SAAS,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;CAStD"}

package/development/overlay/overlay.d.ts

@@ -0,0 +1,52 @@
+import { CSSResultGroup, TemplateResult } from 'lit';
+import { SbbOverlayBaseElement } from './overlay-base-element.js';
+
+/**
+ * It displays an interactive overlay element.
+ *
+ * @slot - Use the unnamed slot to provide a content for the overlay.
+ * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-overlay` starts the opening transition. Can be canceled.
+ * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-overlay` is opened.
+ * @event {CustomEvent<void>} willClose - Emits whenever the `sbb-overlay` begins the closing transition. Can be canceled.
+ * @event {CustomEvent<SbbOverlayCloseEventDetails>} didClose - Emits whenever the `sbb-overlay` is closed.
+ * @event {CustomEvent<void>} requestBackAction - Emits whenever the back button is clicked.
+ * @cssprop [--sbb-overlay-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`.
+ */
+export declare class SbbOverlayElement extends SbbOverlayBaseElement {
+    static styles: CSSResultGroup;
+    static readonly events: {
+        readonly willOpen: "willOpen";
+        readonly didOpen: "didOpen";
+        readonly willClose: "willClose";
+        readonly didClose: "didClose";
+        readonly backClick: "requestBackAction";
+    };
+    /**
+     * Whether to allow the overlay content to stretch to full width.
+     * By default, the content has the appropriate page size.
+     */
+    expanded: boolean;
+    /** Whether a back button is displayed next to the title. */
+    backButton: boolean;
+    /** This will be forwarded as aria-label to the close button element. */
+    accessibilityCloseLabel: string | undefined;
+    /** This will be forwarded as aria-label to the back button element. */
+    accessibilityBackLabel: string | undefined;
+    protected closeAttribute: string;
+    /** Emits whenever the back button is clicked. */
+    private _backClick;
+    private _overlayContentElement;
+    /** Opens the component. */
+    open(): void;
+    protected onOverlayAnimationEnd(event: AnimationEvent): void;
+    protected setOverlayFocus(): void;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-overlay': SbbOverlayElement;
+    }
+}
+//# sourceMappingURL=overlay.d.ts.map

package/development/overlay/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../../src/elements/overlay/overlay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAU1D,OAAO,EAAe,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAE/E,OAAO,+BAA+B,CAAC;AACvC,OAAO,iCAAiC,CAAC;AACzC,OAAO,iBAAiB,CAAC;AACzB,OAAO,0BAA0B,CAAC;AAElC;;;;;;;;;;;;GAYG;AACH,qBACa,iBAAkB,SAAQ,qBAAqB;IAC1D,OAAuB,MAAM,EAAE,cAAc,CAAS;IAGtD,gBAAgC,MAAM;;;;;;MAM3B;IAEX;;;OAGG;IACgD,QAAQ,UAAS;IAEpE,4DAA4D;IACE,UAAU,UAAS;IAEjF,wEAAwE;IACX,uBAAuB,EAChF,MAAM,GACN,SAAS,CAAC;IAEd,uEAAuE;IACX,sBAAsB,EAC9E,MAAM,GACN,SAAS,CAAC;IAEd,SAAS,CAAC,cAAc,EAAE,MAAM,CAAuB;IAEvD,iDAAiD;IACjD,OAAO,CAAC,UAAU,CAGhB;IACF,OAAO,CAAC,sBAAsB,CAA4B;IAE1D,2BAA2B;IACpB,IAAI,IAAI,IAAI;IAyBnB,SAAS,CAAC,qBAAqB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IA8B5D,SAAS,CAAC,eAAe,IAAI,IAAI;cAUd,MAAM,IAAI,cAAc;CAyD5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,aAAa,EAAE,iBAAiB,CAAC;KAClC;CACF"}

package/development/overlay.d.ts

@@ -0,0 +1,3 @@
+export * from './overlay/overlay.js';
+export * from './overlay/overlay-base-element.js';
+//# sourceMappingURL=overlay.d.ts.map

package/development/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../src/elements/overlay.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC"}