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

package/development/slider.component-BLptxiZ4.js

@@ -0,0 +1,346 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, nothing, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbDisabledMixin, SbbElement, SbbFormAssociatedMixin, SbbReadonlyMixin, forceType, hostAttributes } from "./core.js";
+import { SbbIconElement } from "./icon.pure.js";
+import { ref } from "lit/directives/ref.js";
+//#region src/elements/slider/slider.scss?inline
+var slider_default = "@charset \"UTF-8\";\n:host {\n  --_sbb-slider-value-fraction: 0;\n  outline: none !important;\n  display: inline-block;\n  min-width: var(--sbb-slider-min-width);\n  width: min(var(--sbb-slider-width), 100%);\n}\n\n:host(:disabled) {\n  --sbb-slider-icon-color: var(--sbb-color-graphite);\n  --sbb-slider-icon-color: light-dark(var(--sbb-color-graphite), var(--sbb-color-smoke));\n  --sbb-slider-knob-border-color: var(--sbb-border-color-5);\n  --sbb-slider-knob-border-size: var(--sbb-border-width-2x);\n  --sbb-slider-knob-border-style: dashed;\n}\n\n:host([readonly]) {\n  --sbb-slider-icon-color: var(--sbb-color-5);\n  --sbb-slider-knob-border-color: var(--sbb-slider-selected-line-disabled-color);\n}\n\n:host(:disabled),\n:host([readonly]) {\n  --sbb-slider-line-color: var(--sbb-slider-line-disabled-color);\n  --sbb-slider-selected-line-color: var(--sbb-slider-selected-line-disabled-color);\n}\n@media (forced-colors: active) {\n  :host(:disabled),\n  :host([readonly]) {\n    --sbb-slider-icon-color: GrayText;\n    --sbb-slider-selected-line-disabled-color: GrayText;\n    --sbb-slider-line-disabled-color: GrayText;\n  }\n}\n\n.sbb-slider__height-container {\n  display: flex;\n  flex-direction: column;\n}\n.sbb-slider__height-container::before {\n  content: \"​\";\n  user-select: none;\n  width: 0;\n  height: 0;\n}\n\n.sbb-slider__wrapper {\n  display: flex;\n  gap: var(--sbb-slider-gap);\n  padding-block: var(--sbb-slider-padding-block);\n  color: var(--sbb-slider-icon-color);\n}\n\n.sbb-slider__container {\n  position: relative;\n  min-height: var(--sbb-size-icon-ui-small);\n  flex-grow: 1;\n}\n\n.sbb-slider__range-input {\n  position: absolute;\n  width: 100%;\n  inset: 0;\n  opacity: 0;\n  margin: 0;\n}\n\n.sbb-slider__line {\n  position: absolute;\n  top: 50%;\n  translate: 0 -50%;\n  height: var(--sbb-slider-line-height);\n  width: 100%;\n  background-color: var(--sbb-slider-line-color);\n  border-radius: var(--sbb-slider-line-height);\n  overflow: hidden;\n  pointer-events: none;\n}\n\n.sbb-slider__selected-line {\n  position: relative;\n  height: 100%;\n  background-color: var(--sbb-slider-selected-line-color);\n  width: calc(var(--_sbb-slider-value-fraction) * 100%);\n}\n\n.sbb-slider__knob {\n  position: absolute;\n  top: 50%;\n  translate: 0 -50%;\n  box-shadow: var(--sbb-box-shadow-level-5-hard);\n  width: var(--sbb-slider-knob-size);\n  height: var(--sbb-slider-knob-size);\n  inset-inline-start: calc(var(--_sbb-slider-value-fraction) * 100% - var(--sbb-slider-knob-size) * var(--_sbb-slider-value-fraction));\n  transition-property: width, height;\n  transition-duration: var(--sbb-disable-animation-duration, var(--sbb-animation-duration-1x));\n  transition-timing-function: ease-in;\n  background-color: var(--sbb-slider-knob-color);\n  border: var(--sbb-slider-knob-border-size) var(--sbb-slider-knob-border-style) var(--sbb-slider-knob-border-color);\n  border-radius: 50%;\n  pointer-events: none;\n}\n:host(:focus-visible) .sbb-slider__knob {\n  outline-offset: var(--sbb-focus-outline-offset);\n  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);\n  --sbb-slider-knob-size: var(--sbb-slider-knob-size-active);\n}\n:host(:not(:is(:disabled, [readonly]))) .sbb-slider__range-input:active ~ .sbb-slider__knob {\n  --sbb-slider-knob-size: var(--sbb-slider-knob-size-active);\n}";
+//#endregion
+//#region src/elements/slider/slider.component.ts
+/**
+* It displays an input knob that can be moved in a range.
+*
+* @slot prefix - Use this slot to render an icon on the left side of the input.
+* @slot suffix - Use this slot to render an icon on the right side of the input.
+* @event {InputEvent} input - The input event fires when the value has been changed as a direct result of a user action.
+*/
+var SbbSliderElement = (() => {
+	let _classDecorators = [hostAttributes({ tabindex: "0" })];
+	let _classDescriptor;
+	let _classExtraInitializers = [];
+	let _classThis;
+	let _classSuper = SbbDisabledMixin(SbbReadonlyMixin(SbbFormAssociatedMixin(SbbElement)));
+	let _instanceExtraInitializers = [];
+	let _set_value_decorators;
+	let _set_valueAsNumber_decorators;
+	let _set_min_decorators;
+	let _set_max_decorators;
+	let _startIcon_decorators;
+	let _startIcon_initializers = [];
+	let _startIcon_extraInitializers = [];
+	let _endIcon_decorators;
+	let _endIcon_initializers = [];
+	let _endIcon_extraInitializers = [];
+	var SbbSliderElement = class extends _classSuper {
+		static {
+			_classThis = this;
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_set_value_decorators = [property()];
+			_set_valueAsNumber_decorators = [property({
+				attribute: "value-as-number",
+				type: Number
+			})];
+			_set_min_decorators = [property()];
+			_set_max_decorators = [property()];
+			_startIcon_decorators = [forceType(), property({ attribute: "start-icon" })];
+			_endIcon_decorators = [forceType(), property({ attribute: "end-icon" })];
+			__esDecorate(this, null, _set_value_decorators, {
+				kind: "setter",
+				name: "value",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "value" in obj,
+					set: (obj, value) => {
+						obj.value = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_valueAsNumber_decorators, {
+				kind: "setter",
+				name: "valueAsNumber",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "valueAsNumber" in obj,
+					set: (obj, value) => {
+						obj.valueAsNumber = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_min_decorators, {
+				kind: "setter",
+				name: "min",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "min" in obj,
+					set: (obj, value) => {
+						obj.min = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_max_decorators, {
+				kind: "setter",
+				name: "max",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "max" in obj,
+					set: (obj, value) => {
+						obj.max = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _startIcon_decorators, {
+				kind: "accessor",
+				name: "startIcon",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "startIcon" in obj,
+					get: (obj) => obj.startIcon,
+					set: (obj, value) => {
+						obj.startIcon = value;
+					}
+				},
+				metadata: _metadata
+			}, _startIcon_initializers, _startIcon_extraInitializers);
+			__esDecorate(this, null, _endIcon_decorators, {
+				kind: "accessor",
+				name: "endIcon",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "endIcon" in obj,
+					get: (obj) => obj.endIcon,
+					set: (obj, value) => {
+						obj.endIcon = value;
+					}
+				},
+				metadata: _metadata
+			}, _endIcon_initializers, _endIcon_extraInitializers);
+			__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, {
+				kind: "class",
+				name: _classThis.name,
+				metadata: _metadata
+			}, null, _classExtraInitializers);
+			SbbSliderElement = _classThis = _classDescriptor.value;
+			if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-slider";
+		}
+		static {
+			this.elementDependencies = [SbbIconElement];
+		}
+		static {
+			this.role = "slider";
+		}
+		static {
+			this.styles = [unsafeCSS(slider_default)];
+		}
+		static {
+			this.events = { didChange: "didChange" };
+		}
+		/**
+		* Value of the form element.
+		* If no value is provided, default is the middle point between min and max.
+		*/
+		set value(value) {
+			if (this._isValidNumber(value)) this._value = this._boundBetweenMinMax(value);
+			else this._value = null;
+			this.internals.ariaValueNow = this.value;
+		}
+		get value() {
+			return this._value ?? this._defaultValue();
+		}
+		/** Numeric value for the inner HTMLInputElement. */
+		set valueAsNumber(value) {
+			this.value = value?.toString() ?? null;
+		}
+		get valueAsNumber() {
+			return Number(this.value);
+		}
+		/** Minimum acceptable value for the inner HTMLInputElement. */
+		set min(value) {
+			if (!this._isValidNumber(value)) return;
+			this._min = value;
+			this.internals.ariaValueMin = this.min;
+			const boundValue = this._boundBetweenMinMax(this.value);
+			if (this.value !== boundValue) this.value = boundValue;
+		}
+		get min() {
+			return this._min;
+		}
+		/** Maximum acceptable value for the inner HTMLInputElement. */
+		set max(value) {
+			if (!this._isValidNumber(value)) return;
+			this._max = value;
+			this.internals.ariaValueMax = this.max;
+			const boundValue = this._boundBetweenMinMax(this.value);
+			if (this.value !== boundValue) this.value = boundValue;
+		}
+		get max() {
+			return this._max;
+		}
+		#startIcon_accessor_storage;
+		/** Name of the icon at component's start, which will be forward to the nested `sbb-icon`. */
+		get startIcon() {
+			return this.#startIcon_accessor_storage;
+		}
+		set startIcon(value) {
+			this.#startIcon_accessor_storage = value;
+		}
+		#endIcon_accessor_storage;
+		/** Name of the icon at component's end, which will be forward to the nested `sbb-icon`. */
+		get endIcon() {
+			return this.#endIcon_accessor_storage;
+		}
+		set endIcon(value) {
+			this.#endIcon_accessor_storage = value;
+		}
+		/**
+		* Form type of element.
+		* @default 'range'
+		*/
+		get type() {
+			return "range";
+		}
+		constructor() {
+			super();
+			this._value = (__runInitializers(this, _instanceExtraInitializers), null);
+			this._min = "0";
+			this._max = "100";
+			this.#startIcon_accessor_storage = __runInitializers(this, _startIcon_initializers, "");
+			this.#endIcon_accessor_storage = (__runInitializers(this, _startIcon_extraInitializers), __runInitializers(this, _endIcon_initializers, ""));
+			/** Reference to the inner HTMLInputElement with type='range'. */
+			this._rangeInput = __runInitializers(this, _endIcon_extraInitializers);
+			this.addEventListener?.("keydown", (e) => this._handleKeydown(e));
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("readOnly")) this.internals.ariaReadOnly = Boolean(this.readOnly).toString();
+			this.style?.setProperty("--_sbb-slider-value-fraction", this._valueFraction().toString());
+		}
+		/**
+		* The reset value is the attribute value (the setup value). If not present, calculates the default.
+		* @internal
+		*/
+		formResetCallback() {
+			this.value = this.getAttribute("value") ?? this._defaultValue();
+		}
+		/**
+		* @internal
+		*/
+		formStateRestoreCallback(state, _reason) {
+			this.value = state;
+		}
+		/**
+		*  If no value is provided, default is the middle point between min and max
+		*  (see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/range#value)
+		*/
+		_defaultValue() {
+			return (+this.min + (+this.max - +this.min) / 2).toString();
+		}
+		_isValidNumber(value) {
+			return !!value && !isNaN(Number(value));
+		}
+		/**
+		* Restrains the value between the min and max
+		*/
+		_boundBetweenMinMax(value) {
+			return Math.max(+this.min, Math.min(+this.max, +value)).toString();
+		}
+		_valueFraction() {
+			const value = this.valueAsNumber;
+			const min = +this.min;
+			const max = +this.max;
+			const mathFraction = (value - min) / (max - min);
+			return isNaN(mathFraction) ? 0 : Math.max(0, Math.min(1, mathFraction));
+		}
+		async _handleKeydown(event) {
+			if (event.key !== "Tab") event.preventDefault();
+			if (this.readOnly) return;
+			if (event.key === "Home") this._rangeInput.value = this.min;
+			else if (event.key === "End") this._rangeInput.value = this.max;
+			else if (event.key === "ArrowLeft" || event.key === "ArrowDown") this._rangeInput.stepDown();
+			else if (event.key === "ArrowRight" || event.key === "ArrowUp") this._rangeInput.stepUp();
+			else if (event.key === "PageDown") this._rangeInput.stepDown((+this.max - +this.min) / 10);
+			else if (event.key === "PageUp") this._rangeInput.stepUp((+this.max - +this.min) / 10);
+			else return;
+			this._rangeInput.dispatchEvent(new InputEvent("input", {
+				bubbles: true,
+				cancelable: true,
+				composed: true
+			}));
+			this._rangeInput.dispatchEvent(new Event("change", { bubbles: true }));
+		}
+		/** Emits the change event. */
+		_dispatchChangeEvent() {
+			/**
+			* The change event is fired when the user modifies the element's value.
+			* Unlike the input event, the change event is not necessarily fired
+			* for each alteration to an element's value.
+			*/
+			this.dispatchEvent(new Event("change", { bubbles: true }));
+			/**
+			* Deprecated. Mirrors change event for React. Will be removed once React properly supports change events.
+			* @deprecated
+			*/
+			this.dispatchEvent(new Event("didChange", { bubbles: true }));
+		}
+		render() {
+			return html`
+      <div class="sbb-slider__height-container">
+        <div class="sbb-slider__wrapper">
+          <slot name="prefix">
+            ${this.startIcon ? html`<sbb-icon name="${this.startIcon}"></sbb-icon>` : nothing}
+          </slot>
+          <div class="sbb-slider__container">
+            <input
+              tabindex="-1"
+              min=${this.min}
+              max=${this.max}
+              ?disabled=${this.disabled || this.formDisabled || this.readOnly}
+              value=${this.value || nothing}
+              class="sbb-slider__range-input"
+              type="range"
+              @change=${() => this._dispatchChangeEvent()}
+              @input=${() => this.value = this._rangeInput.value}
+              ${ref((input) => this._rangeInput = input)}
+            />
+            <div class="sbb-slider__line">
+              <div class="sbb-slider__selected-line"></div>
+            </div>
+            <div class="sbb-slider__knob"></div>
+          </div>
+          <slot name="suffix">
+            ${this.endIcon ? html`<sbb-icon name="${this.endIcon}"></sbb-icon>` : nothing}
+          </slot>
+        </div>
+      </div>
+    `;
+		}
+		static {
+			__runInitializers(_classThis, _classExtraInitializers);
+		}
+	};
+	return _classThis;
+})();
+//#endregion
+export { SbbSliderElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"slider.component-BLptxiZ4.js","names":[],"sources":["../../../src/elements/slider/slider.scss?inline","../../../src/elements/slider/slider.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  --_sbb-slider-value-fraction: 0;\n\n  // Use !important here to not interfere with Firefox focus ring definition\n  // which appears in normalize CSS of several frameworks.\n  outline: none !important;\n  display: inline-block;\n  min-width: var(--sbb-slider-min-width);\n  width: min(var(--sbb-slider-width), 100%);\n}\n\n:host(:disabled) {\n  --sbb-slider-icon-color: light-dark(var(--sbb-color-graphite), var(--sbb-color-smoke));\n  --sbb-slider-knob-border-color: var(--sbb-border-color-5);\n  --sbb-slider-knob-border-size: var(--sbb-border-width-2x);\n  --sbb-slider-knob-border-style: dashed;\n}\n\n:host([readonly]) {\n  --sbb-slider-icon-color: var(--sbb-color-5);\n  --sbb-slider-knob-border-color: var(--sbb-slider-selected-line-disabled-color);\n}\n\n:host(:disabled),\n:host([readonly]) {\n  --sbb-slider-line-color: var(--sbb-slider-line-disabled-color);\n  --sbb-slider-selected-line-color: var(--sbb-slider-selected-line-disabled-color);\n\n  @media (forced-colors: active) {\n    --sbb-slider-icon-color: GrayText;\n    --sbb-slider-selected-line-disabled-color: GrayText;\n    --sbb-slider-line-disabled-color: GrayText;\n  }\n}\n\n.sbb-slider__height-container {\n  display: flex;\n  flex-direction: column;\n\n  // Currently, the slider is becoming a too large height in the surrounding content.\n  // Changing height of the children of the container to\n  // 17px solves the issue, but cuts the slider.\n  @include sbb.zero-width-space;\n}\n\n.sbb-slider__wrapper {\n  display: flex;\n  gap: var(--sbb-slider-gap);\n  padding-block: var(--sbb-slider-padding-block);\n  color: var(--sbb-slider-icon-color);\n}\n\n.sbb-slider__container {\n  position: relative;\n  min-height: var(--sbb-size-icon-ui-small);\n  flex-grow: 1;\n}\n\n.sbb-slider__range-input {\n  position: absolute;\n  width: 100%;\n  inset: 0;\n  opacity: 0;\n  margin: 0;\n}\n\n.sbb-slider__line {\n  @include sbb.absolute-center-y;\n\n  height: var(--sbb-slider-line-height);\n  width: 100%;\n  background-color: var(--sbb-slider-line-color);\n  border-radius: var(--sbb-slider-line-height);\n  overflow: hidden;\n  pointer-events: none;\n}\n\n.sbb-slider__selected-line {\n  position: relative;\n  height: 100%;\n  background-color: var(--sbb-slider-selected-line-color);\n  width: calc(var(--_sbb-slider-value-fraction) * 100%);\n}\n\n.sbb-slider__knob {\n  @include sbb.absolute-center-y;\n\n  box-shadow: var(--sbb-box-shadow-level-5-hard);\n  width: var(--sbb-slider-knob-size);\n  height: var(--sbb-slider-knob-size);\n  inset-inline-start: calc(\n    calc(var(--_sbb-slider-value-fraction) * 100%) - var(--sbb-slider-knob-size) *\n      var(--_sbb-slider-value-fraction)\n  );\n  transition-property: width, height;\n  transition-duration: var(--sbb-disable-animation-duration, var(--sbb-animation-duration-1x));\n  transition-timing-function: ease-in;\n  background-color: var(--sbb-slider-knob-color);\n  border: var(--sbb-slider-knob-border-size) var(--sbb-slider-knob-border-style)\n    var(--sbb-slider-knob-border-color);\n  border-radius: 50%;\n  pointer-events: none;\n\n  :host(:focus-visible) & {\n    @include sbb.focus-outline;\n\n    --sbb-slider-knob-size: var(--sbb-slider-knob-size-active);\n  }\n\n  // slider knob resize on click (active / focus)\n  :host(:not(:is(:disabled, [readonly]))) .sbb-slider__range-input:active ~ & {\n    --sbb-slider-knob-size: var(--sbb-slider-knob-size-active);\n  }\n}\n","import {\n  type CSSResultGroup,\n  html,\n  nothing,\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  type FormRestoreReason,\n  type FormRestoreState,\n  hostAttributes,\n  SbbDisabledMixin,\n  SbbElement,\n  type SbbElementType,\n  SbbFormAssociatedMixin,\n  SbbReadonlyMixin,\n} from '../core.ts';\nimport { SbbIconElement } from '../icon.pure.ts';\n\nimport style from './slider.scss?inline';\n\n/**\n * It displays an input knob that can be moved in a range.\n *\n * @slot prefix - Use this slot to render an icon on the left side of the input.\n * @slot suffix - Use this slot to render an icon on the right side of the input.\n * @event {InputEvent} input - The input event fires when the value has been changed as a direct result of a user action.\n */\nexport\n@hostAttributes({\n  tabindex: '0',\n})\nclass SbbSliderElement extends SbbDisabledMixin(\n  SbbReadonlyMixin(SbbFormAssociatedMixin(SbbElement)),\n) {\n  public static override readonly elementName: string = 'sbb-slider';\n  public static override elementDependencies: SbbElementType[] = [SbbIconElement];\n  public static override readonly role = 'slider';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n  public static readonly events = {\n    didChange: 'didChange',\n  } as const;\n\n  /**\n   * Value of the form element.\n   * If no value is provided, default is the middle point between min and max.\n   */\n  @property()\n  public set value(value: string | null) {\n    if (this._isValidNumber(value)) {\n      this._value = this._boundBetweenMinMax(value);\n    } else {\n      this._value = null;\n    }\n    this.internals.ariaValueNow = this.value;\n  }\n  public get value(): string {\n    return this._value ?? this._defaultValue();\n  }\n  private _value: string | null = null;\n\n  /** Numeric value for the inner HTMLInputElement. */\n  @property({ attribute: 'value-as-number', type: Number })\n  public set valueAsNumber(value: number | null) {\n    this.value = value?.toString() ?? null;\n  }\n  public get valueAsNumber(): number | null {\n    return Number(this.value);\n  }\n\n  /** Minimum acceptable value for the inner HTMLInputElement. */\n  @property()\n  public set min(value: string) {\n    if (!this._isValidNumber(value)) {\n      return;\n    }\n\n    this._min = value;\n    this.internals.ariaValueMin = this.min;\n    const boundValue = this._boundBetweenMinMax(this.value);\n    if (this.value !== boundValue) {\n      this.value = boundValue;\n    }\n  }\n  public get min(): string {\n    return this._min;\n  }\n  private _min: string = '0';\n\n  /** Maximum acceptable value for the inner HTMLInputElement. */\n  @property()\n  public set max(value: string) {\n    if (!this._isValidNumber(value)) {\n      return;\n    }\n\n    this._max = value;\n    this.internals.ariaValueMax = this.max;\n    const boundValue = this._boundBetweenMinMax(this.value);\n    if (this.value !== boundValue) {\n      this.value = boundValue;\n    }\n  }\n  public get max(): string {\n    return this._max;\n  }\n  private _max: string = '100';\n\n  /** Name of the icon at component's start, which will be forward to the nested `sbb-icon`. */\n  @forceType()\n  @property({ attribute: 'start-icon' })\n  public accessor startIcon: string = '';\n\n  /** Name of the icon at component's end, which will be forward to the nested `sbb-icon`. */\n  @forceType()\n  @property({ attribute: 'end-icon' })\n  public accessor endIcon: string = '';\n\n  /**\n   * Form type of element.\n   * @default 'range'\n   */\n  public override get type(): string {\n    return 'range';\n  }\n\n  /** Reference to the inner HTMLInputElement with type='range'. */\n  private _rangeInput!: HTMLInputElement;\n\n  public constructor() {\n    super();\n    this.addEventListener?.('keydown', (e) => this._handleKeydown(e));\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('readOnly')) {\n      this.internals.ariaReadOnly = Boolean(this.readOnly).toString();\n    }\n    this.style?.setProperty('--_sbb-slider-value-fraction', this._valueFraction().toString());\n  }\n\n  /**\n   * The reset value is the attribute value (the setup value). If not present, calculates the default.\n   * @internal\n   */\n  public formResetCallback(): void {\n    this.value = this.getAttribute('value') ?? this._defaultValue();\n  }\n\n  /**\n   * @internal\n   */\n  public formStateRestoreCallback(\n    state: FormRestoreState | null,\n    _reason: FormRestoreReason,\n  ): void {\n    this.value = state as string | null;\n  }\n\n  /**\n   *  If no value is provided, default is the middle point between min and max\n   *  (see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/range#value)\n   */\n  private _defaultValue(): string {\n    return (+this.min + (+this.max - +this.min) / 2).toString();\n  }\n\n  private _isValidNumber(value: string | null): value is string {\n    return !!value && !isNaN(Number(value));\n  }\n\n  /**\n   * Restrains the value between the min and max\n   */\n  private _boundBetweenMinMax(value: string): string {\n    return Math.max(+this.min, Math.min(+this.max, +value)).toString();\n  }\n\n  private _valueFraction(): number {\n    const value = this.valueAsNumber!;\n    const min = +this.min;\n    const max = +this.max;\n\n    const mathFraction: number = (value - min) / (max - min);\n    return isNaN(mathFraction) ? 0 : Math.max(0, Math.min(1, mathFraction));\n  }\n\n  private async _handleKeydown(event: KeyboardEvent): Promise<void> {\n    if (event.key !== 'Tab') {\n      event.preventDefault();\n    }\n\n    if (this.readOnly) {\n      return;\n    }\n\n    if (event.key === 'Home') {\n      this._rangeInput.value = this.min;\n    } else if (event.key === 'End') {\n      this._rangeInput.value = this.max;\n    } else if (event.key === 'ArrowLeft' || event.key === 'ArrowDown') {\n      this._rangeInput.stepDown();\n    } else if (event.key === 'ArrowRight' || event.key === 'ArrowUp') {\n      this._rangeInput.stepUp();\n    } else if (event.key === 'PageDown') {\n      this._rangeInput.stepDown((+this.max - +this.min) / 10);\n    } else if (event.key === 'PageUp') {\n      this._rangeInput.stepUp((+this.max - +this.min) / 10);\n    } else {\n      return;\n    }\n\n    // We have to manually fire events because programmatic changes don't trigger them\n    this._rangeInput.dispatchEvent(\n      new InputEvent('input', { bubbles: true, cancelable: true, composed: true }),\n    );\n    this._rangeInput.dispatchEvent(new Event('change', { bubbles: true }));\n  }\n\n  /** Emits the change event. */\n  private _dispatchChangeEvent(): void {\n    /**\n     * The change event is fired when the user modifies the element's value.\n     * Unlike the input event, the change event is not necessarily fired\n     * for each alteration to an element's value.\n     */\n    this.dispatchEvent(new Event('change', { bubbles: true }));\n\n    /**\n     * Deprecated. Mirrors change event for React. Will be removed once React properly supports change events.\n     * @deprecated\n     */\n    this.dispatchEvent(new Event('didChange', { bubbles: true }));\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-slider__height-container\">\n        <div class=\"sbb-slider__wrapper\">\n          <slot name=\"prefix\">\n            ${this.startIcon ? html`<sbb-icon name=\"${this.startIcon}\"></sbb-icon>` : nothing}\n          </slot>\n          <div class=\"sbb-slider__container\">\n            <input\n              tabindex=\"-1\"\n              min=${this.min}\n              max=${this.max}\n              ?disabled=${this.disabled || this.formDisabled || this.readOnly}\n              value=${this.value || nothing}\n              class=\"sbb-slider__range-input\"\n              type=\"range\"\n              @change=${() => this._dispatchChangeEvent()}\n              @input=${() => (this.value = this._rangeInput.value)}\n              ${ref((input?: Element) => (this._rangeInput = input as HTMLInputElement))}\n            />\n            <div class=\"sbb-slider__line\">\n              <div class=\"sbb-slider__selected-line\"></div>\n            </div>\n            <div class=\"sbb-slider__knob\"></div>\n          </div>\n          <slot name=\"suffix\">\n            ${this.endIcon ? html`<sbb-icon name=\"${this.endIcon}\"></sbb-icon>` : nothing}\n          </slot>\n        </div>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-slider': SbbSliderElement;\n  }\n}\n"],"mappings":"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"}

package/development/slider.js

@@ -1,4 +1,4 @@
-import { t as SbbSliderElement } from "./slider.component-D_nLTlRF.js";
+import { t as SbbSliderElement } from "./slider.component-BLptxiZ4.js";
 import "./slider.pure.js";
 //#region src/elements/slider.ts
 /** @entrypoint */

package/development/slider.pure.js

@@ -1,2 +1,2 @@
-import { t as SbbSliderElement } from "./slider.component-D_nLTlRF.js";
+import { t as SbbSliderElement } from "./slider.component-BLptxiZ4.js";
 export { SbbSliderElement };

package/development/status/status.component.js

@@ -1,2 +1,2 @@
-import { t as SbbStatusElement } from "../status.component-B9en2l26.js";
+import { t as SbbStatusElement } from "../status.component-thSGiOrl.js";
 export { SbbStatusElement };

package/development/{status.component-B9en2l26.js → status.component-thSGiOrl.js}

@@ -107,4 +107,4 @@ var SbbStatusElement = (() => {
 //#endregion
 export { SbbStatusElement as t };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"status.component-B9en2l26.js","names":[],"sources":["../../../src/elements/status/status.scss?inline","../../../src/elements/status/status.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  --sbb-status-text-color: var(--sbb-status-color);\n\n  display: flex;\n  gap: var(--sbb-status-gap);\n  color: var(--sbb-status-text-color);\n  font-size: var(--sbb-status-font-size);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n  line-height: var(--sbb-typo-line-height-text);\n}\n\n:host([type='error']) {\n  --sbb-status-color: var(--sbb-color-error);\n}\n\n:host([type='success']) {\n  --sbb-status-color: var(--sbb-color-success);\n}\n\n:host([type='warning']) {\n  --sbb-status-color: var(--sbb-color-2);\n}\n\n:host([type='pending']) {\n  --sbb-status-color: var(--sbb-color-sky);\n}\n\n:host([type='incomplete']) {\n  --sbb-status-color: var(--sbb-color-error);\n}\n\n:host([type='not-started']) {\n  --sbb-status-color: var(--sbb-color-5);\n  --sbb-status-text-color: var(--sbb-color-2);\n}\n\n:host([type='in-progress']) {\n  --sbb-status-color: var(--sbb-color-pink);\n}\n\n:host(:state(slotted-title)) {\n  --sbb-status-gap: var(--sbb-spacing-responsive-xxxs);\n  --_sbb-status-title-font-size: var(--sbb-heading-font-size-5);\n  --_sbb-status-title-line-height: var(--sbb-typo-line-height-heading);\n\n  color: var(--sbb-status-title-color);\n}\n\n.sbb-status__icon {\n  display: flex;\n  flex-shrink: 0;\n  color: var(--sbb-status-color);\n  margin-block-start: calc(\n    (\n        (\n            var(--_sbb-status-title-font-size, var(--sbb-status-font-size)) *\n              var(--_sbb-status-title-line-height, var(--sbb-typo-line-height-text))\n          ) - var(--sbb-size-icon-ui-small)\n      ) /\n      2\n  );\n}\n\n.sbb-status__content-slot {\n  // Reset paragraph styles\n  display: inline;\n  margin: 0;\n  padding: 0;\n}\n\n::slotted(sbb-title) {\n  margin-block: 0;\n}\n","import { type CSSResultGroup, html, type TemplateResult, unsafeCSS } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbElement } from '../core.ts';\nimport { SbbIconNameMixin } from '../icon.pure.ts';\nimport type { SbbTitleElement } from '../title.pure.ts';\n\nimport style from './status.scss?inline';\n\n/**\n * Displays a message to the user's attention.\n *\n * @slot - Use the unnamed slot to add an optional `sbb-title` and content to the status message.\n * @slot icon - Use this slot to override the default status icon.\n * @slot title - Slot for the title. For the standard `sbb-title` element, the slot is automatically assigned when slotted in the unnamed slot.\n * @cssprop [--sbb-status-color=var(--sbb-color-iron)] - Specify a custom color,\n * which will override the predefined color for any type.\n * @cssprop [--sbb-status-text-color=var(--sbb-status-color)] - Specify a custom text color,\n * which will override the predefined color for any type. Only valid for a status without a title.\n */\nexport class SbbStatusElement extends SbbIconNameMixin(SbbElement) {\n  public static override readonly elementName: string = 'sbb-status';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n\n  private readonly _statusTypes: Map<SbbStatusElement['type'], string> = new Map([\n    ['info', 'circle-information-small'],\n    ['success', 'circle-tick-small'],\n    ['warning', 'circle-exclamation-point-small'],\n    ['error', 'circle-cross-small'],\n    ['pending', 'circle-three-dots-small'],\n    ['incomplete', 'circle-dotted-part-x-small'],\n    ['not-started', 'circle-dotted-small'],\n    ['in-progress', 'circle-dotted-part-small'],\n  ]);\n\n  /** The type of the status. */\n  @property({ reflect: true }) public accessor type:\n    | 'info'\n    | 'success'\n    | 'warning'\n    | 'error'\n    | 'pending'\n    | 'incomplete'\n    | 'not-started'\n    | 'in-progress' = 'info';\n\n  private _handleSlotchange(): void {\n    const title = Array.from(this.children).find((el) => el.localName === 'sbb-title');\n    if (title) {\n      title.slot = 'title';\n    }\n  }\n\n  private _configureTitle(event: Event): void {\n    const title = (event.target as HTMLSlotElement)\n      .assignedElements()\n      .find((e): e is SbbTitleElement => e.localName === 'sbb-title');\n    if (title) {\n      customElements.upgrade(title);\n      title.visualLevel = '5';\n    }\n  }\n\n  protected override renderIconName(): string {\n    return super.renderIconName() || this._statusTypes.get(this.type)!;\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <span class=\"sbb-status__icon\"> ${this.renderIconSlot()} </span>\n      <span class=\"sbb-status__content\">\n        <slot name=\"title\" @slotchange=${this._configureTitle}></slot>\n        <p class=\"sbb-status__content-slot\" @slotchange=${this._handleSlotchange}>\n          <slot></slot>\n        </p>\n      </span>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-status': SbbStatusElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;ICoBa,0BAAgB;mBAAS,iBAAiB,UAAU;;;;cAApD,yBAAyB,YAA4B;;;uBAgB/D,SAAS,EAAE,SAAS,KAAI,CAAE,CAAC;GAAC,aAAA,MAAA,MAAA,kBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,UAAA;KAAA,MAAA,QAAA,IAAgB;KAAI,MAAA,KAAA,UAAA;MAAA,IAAJ,OAAI;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,oBAAA,uBAAA;;;;;;;;;GAfjB,KAAA,cAAsB;EAAa;;GAC5C,KAAA,SAAyB,CAAC,UAAU,cAAK,CAAC;EAAE;EActC;;EAAA,IAAgB,OAAI;GAAA,OAAA,KAAA;EAAA;EAApB,IAAgB,KAAI,OAAA;GAAA,KAAA,yBAAA;EAAA;EAUzC,oBAAiB;GACvB,MAAM,QAAQ,MAAM,KAAK,KAAK,QAAQ,EAAE,MAAM,OAAO,GAAG,cAAc,WAAW;GACjF,IAAI,OACF,MAAM,OAAO;EAEjB;EAEQ,gBAAgB,OAAY;GAClC,MAAM,QAAS,MAAM,OAClB,iBAAgB,EAChB,MAAM,MAA4B,EAAE,cAAc,WAAW;GAChE,IAAI,OAAO;IACT,eAAe,QAAQ,KAAK;IAC5B,MAAM,cAAc;GACtB;EACF;EAEmB,iBAAc;GAC/B,OAAO,MAAM,eAAc,KAAM,KAAK,aAAa,IAAI,KAAK,IAAI;EAClE;EAEmB,SAAM;GACvB,OAAO,IAAI;wCACyB,KAAK,eAAc,EAAE;;yCAEpB,KAAK,gBAAe;0DACH,KAAK,kBAAiB;;;;;EAK9E;;;GArDiB,KAAA,eAAsD,IAAI,IAAI;IAC7E,CAAC,QAAQ,0BAA0B;IACnC,CAAC,WAAW,mBAAmB;IAC/B,CAAC,WAAW,gCAAgC;IAC5C,CAAC,SAAS,oBAAoB;IAC9B,CAAC,WAAW,yBAAyB;IACrC,CAAC,cAAc,4BAA4B;IAC3C,CAAC,eAAe,qBAAqB;IACrC,CAAC,eAAe,0BAA0B;IAC3C;GAG4C,KAAA,yBAAA,kBAAA,MAAA,oBAQzB,MAAM"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"status.component-thSGiOrl.js","names":[],"sources":["../../../src/elements/status/status.scss?inline","../../../src/elements/status/status.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  --sbb-status-text-color: var(--sbb-status-color);\n\n  display: flex;\n  gap: var(--sbb-status-gap);\n  color: var(--sbb-status-text-color);\n  font-size: var(--sbb-status-font-size);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n  line-height: var(--sbb-typo-line-height-text);\n}\n\n:host([type='error']) {\n  --sbb-status-color: var(--sbb-color-error);\n}\n\n:host([type='success']) {\n  --sbb-status-color: var(--sbb-color-success);\n}\n\n:host([type='warning']) {\n  --sbb-status-color: var(--sbb-color-2);\n}\n\n:host([type='pending']) {\n  --sbb-status-color: var(--sbb-color-sky);\n}\n\n:host([type='incomplete']) {\n  --sbb-status-color: var(--sbb-color-error);\n}\n\n:host([type='not-started']) {\n  --sbb-status-color: var(--sbb-color-5);\n  --sbb-status-text-color: var(--sbb-color-2);\n}\n\n:host([type='in-progress']) {\n  --sbb-status-color: var(--sbb-color-pink);\n}\n\n:host(:state(slotted-title)) {\n  --sbb-status-gap: var(--sbb-spacing-responsive-xxxs);\n  --_sbb-status-title-font-size: var(--sbb-heading-font-size-5);\n  --_sbb-status-title-line-height: var(--sbb-typo-line-height-heading);\n\n  color: var(--sbb-status-title-color);\n}\n\n.sbb-status__icon {\n  display: flex;\n  flex-shrink: 0;\n  color: var(--sbb-status-color);\n  margin-block-start: calc(\n    (\n        (\n            var(--_sbb-status-title-font-size, var(--sbb-status-font-size)) *\n              var(--_sbb-status-title-line-height, var(--sbb-typo-line-height-text))\n          ) - var(--sbb-size-icon-ui-small)\n      ) /\n      2\n  );\n}\n\n.sbb-status__content-slot {\n  // Reset paragraph styles\n  display: inline;\n  margin: 0;\n  padding: 0;\n}\n\n::slotted(sbb-title) {\n  margin-block: 0;\n}\n","import { type CSSResultGroup, html, type TemplateResult, unsafeCSS } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbElement } from '../core.ts';\nimport { SbbIconNameMixin } from '../icon.pure.ts';\nimport type { SbbTitleElement } from '../title.pure.ts';\n\nimport style from './status.scss?inline';\n\n/**\n * Displays a message to the user's attention.\n *\n * @slot - Use the unnamed slot to add an optional `sbb-title` and content to the status message.\n * @slot icon - Use this slot to override the default status icon.\n * @slot title - Slot for the title. For the standard `sbb-title` element, the slot is automatically assigned when slotted in the unnamed slot.\n * @cssprop [--sbb-status-color=var(--sbb-color-iron)] - Specify a custom color,\n * which will override the predefined color for any type.\n * @cssprop [--sbb-status-text-color=var(--sbb-status-color)] - Specify a custom text color,\n * which will override the predefined color for any type. Only valid for a status without a title.\n */\nexport class SbbStatusElement extends SbbIconNameMixin(SbbElement) {\n  public static override readonly elementName: string = 'sbb-status';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n\n  private readonly _statusTypes: Map<SbbStatusElement['type'], string> = new Map([\n    ['info', 'circle-information-small'],\n    ['success', 'circle-tick-small'],\n    ['warning', 'circle-exclamation-point-small'],\n    ['error', 'circle-cross-small'],\n    ['pending', 'circle-three-dots-small'],\n    ['incomplete', 'circle-dotted-part-x-small'],\n    ['not-started', 'circle-dotted-small'],\n    ['in-progress', 'circle-dotted-part-small'],\n  ]);\n\n  /** The type of the status. */\n  @property({ reflect: true }) public accessor type:\n    | 'info'\n    | 'success'\n    | 'warning'\n    | 'error'\n    | 'pending'\n    | 'incomplete'\n    | 'not-started'\n    | 'in-progress' = 'info';\n\n  private _handleSlotchange(): void {\n    const title = Array.from(this.children).find((el) => el.localName === 'sbb-title');\n    if (title) {\n      title.slot = 'title';\n    }\n  }\n\n  private _configureTitle(event: Event): void {\n    const title = (event.target as HTMLSlotElement)\n      .assignedElements()\n      .find((e): e is SbbTitleElement => e.localName === 'sbb-title');\n    if (title) {\n      customElements.upgrade(title);\n      title.visualLevel = '5';\n    }\n  }\n\n  protected override renderIconName(): string {\n    return super.renderIconName() || this._statusTypes.get(this.type)!;\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <span class=\"sbb-status__icon\"> ${this.renderIconSlot()} </span>\n      <span class=\"sbb-status__content\">\n        <slot name=\"title\" @slotchange=${this._configureTitle}></slot>\n        <p class=\"sbb-status__content-slot\" @slotchange=${this._handleSlotchange}>\n          <slot></slot>\n        </p>\n      </span>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-status': SbbStatusElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;ICoBa,0BAAgB;mBAAS,iBAAiB,UAAU;;;;cAApD,yBAAyB,YAA4B;;;uBAgB/D,SAAS,EAAE,SAAS,KAAI,CAAE,CAAC;GAAC,aAAA,MAAA,MAAA,kBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,UAAA;KAAA,MAAA,QAAA,IAAgB;KAAI,MAAA,KAAA,UAAA;MAAA,IAAJ,OAAI;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,oBAAA,uBAAA;;;;;;;;;GAfjB,KAAA,cAAsB;EAAa;;GAC5C,KAAA,SAAyB,CAAC,UAAU,cAAK,CAAC;EAAE;EActC;;EAAA,IAAgB,OAAI;GAAA,OAAA,KAAA;EAAA;EAApB,IAAgB,KAAI,OAAA;GAAA,KAAA,yBAAA;EAAA;EAUzC,oBAAiB;GACvB,MAAM,QAAQ,MAAM,KAAK,KAAK,QAAQ,EAAE,MAAM,OAAO,GAAG,cAAc,WAAW;GACjF,IAAI,OACF,MAAM,OAAO;EAEjB;EAEQ,gBAAgB,OAAY;GAClC,MAAM,QAAS,MAAM,OAClB,iBAAgB,EAChB,MAAM,MAA4B,EAAE,cAAc,WAAW;GAChE,IAAI,OAAO;IACT,eAAe,QAAQ,KAAK;IAC5B,MAAM,cAAc;GACtB;EACF;EAEmB,iBAAc;GAC/B,OAAO,MAAM,eAAc,KAAM,KAAK,aAAa,IAAI,KAAK,IAAI;EAClE;EAEmB,SAAM;GACvB,OAAO,IAAI;wCACyB,KAAK,eAAc,EAAE;;yCAEpB,KAAK,gBAAe;0DACH,KAAK,kBAAiB;;;;;EAK9E;;;GArDiB,KAAA,eAAsD,IAAI,IAAI;IAC7E,CAAC,QAAQ,0BAA0B;IACnC,CAAC,WAAW,mBAAmB;IAC/B,CAAC,WAAW,gCAAgC;IAC5C,CAAC,SAAS,oBAAoB;IAC9B,CAAC,WAAW,yBAAyB;IACrC,CAAC,cAAc,4BAA4B;IAC3C,CAAC,eAAe,qBAAqB;IACrC,CAAC,eAAe,0BAA0B;IAC3C;GAG4C,KAAA,yBAAA,kBAAA,MAAA,oBAQzB,MAAM"}

package/development/status.js

@@ -1,4 +1,4 @@
-import { t as SbbStatusElement } from "./status.component-B9en2l26.js";
+import { t as SbbStatusElement } from "./status.component-thSGiOrl.js";
 import "./status.pure.js";
 //#region src/elements/status.ts
 /** @entrypoint */

package/development/status.pure.js

@@ -1,2 +1,2 @@
-import { t as SbbStatusElement } from "./status.component-B9en2l26.js";
+import { t as SbbStatusElement } from "./status.component-thSGiOrl.js";
 export { SbbStatusElement };

package/development/step-label.component-CpdXVv32.js

@@ -0,0 +1,127 @@
+import { html, unsafeCSS } from "lit";
+import { SbbButtonBaseElement, SbbDisabledMixin, SbbPropertyWatcherController, appendAriaElements, removeAriaElements } from "./core.js";
+import { SbbIconNameMixin } from "./icon.pure.js";
+//#region src/elements/stepper/step-label/step-label.scss?inline
+var step_label_default = ":host {\n  --sbb-step-label-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-2x)\n  );\n  position: relative;\n  display: flex;\n  min-width: 0;\n  max-width: fit-content;\n  gap: var(--sbb-step-label-gap);\n  cursor: var(--sbb-step-label-cursor);\n  color: var(--sbb-step-label-color);\n  font-size: var(--sbb-step-label-font-size);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n  line-height: var(--sbb-typo-line-height-text);\n}\n:host::before {\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  translate: -50% -50%;\n  font-size: var(--sbb-step-label-number-font-size);\n  font-weight: var(--sbb-step-label-font-weight-selected, normal);\n  inset-block-start: calc(var(--sbb-step-label-font-size) * var(--sbb-typo-line-height-text) / 2 + var(--sbb-border-width-1x) / 2);\n  inset-inline-start: calc(var(--sbb-step-label-prefix-size) / 2);\n  line-height: 1;\n  z-index: 1;\n  translate: -50% calc(-50% + var(--sbb-step-label-translate-y-content-hover, 0px));\n  transition: translate var(--sbb-step-label-animation-duration) var(--sbb-animation-easing);\n}\n\n:host(:is(:state(selected),[state--selected])) {\n  --sbb-step-label-color: var(--sbb-color-3);\n  --sbb-step-label-font-weight-selected: bold;\n}\n@media (forced-colors: active) {\n  :host(:is(:state(selected),[state--selected])) {\n    --sbb-step-label-color: Highlight !important;\n  }\n}\n\n:host(:is(:state(size-s),[state--size-s])) {\n  --sbb-step-label-gap: var(--sbb-step-label-gap-s);\n  --sbb-step-label-prefix-size: var(--sbb-step-label-prefix-size-s);\n  --sbb-step-label-font-size: var(--sbb-step-label-font-size-s);\n}\n\n:host(:is(:state(size-m),[state--size-m])) {\n  --sbb-step-label-gap: var(--sbb-step-label-gap-m);\n  --sbb-step-label-prefix-size: var(--sbb-step-label-prefix-size-m);\n  --sbb-step-label-font-size: var(--sbb-step-label-font-size-m);\n}\n\n:host(:disabled) {\n  --sbb-step-label-color: var(--sbb-color-granite);\n  --sbb-step-label-color: light-dark(var(--sbb-color-granite), var(--sbb-color-graphite));\n  --sbb-step-label-prefix-border-style: dashed;\n}\n@media (forced-colors: active) {\n  :host(:disabled) {\n    --sbb-step-label-color: GrayText !important;\n  }\n}\n\n@media (any-hover: hover) {\n  :host(:hover:not(:disabled)) {\n    --sbb-step-label-cursor: var(--sbb-cursor-pointer);\n    --sbb-step-label-prefix-background-color: var(--sbb-background-color-3);\n    --sbb-step-label-translate-y-content-hover: -0.0625rem;\n    --sbb-step-label-prefix-size-grow-hover: calc(var(--sbb-border-width-2x) * -1);\n  }\n}\n\n:host(:focus-visible) {\n  outline-offset: var(--sbb-focus-outline-offset);\n  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);\n  border-radius: var(--sbb-border-radius-1x);\n}\n\n:host(:is(:state(orientation-vertical),[state--orientation-vertical])) {\n  transition: margin var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n}\n\n:host(:is(:state(orientation-vertical),[state--orientation-vertical]):not(:first-of-type)) {\n  margin-block-start: var(--sbb-spacing-fixed-6x);\n}\n\n:host(:is(:state(selected),[state--selected]):is(:state(orientation-vertical),[state--orientation-vertical])) {\n  margin-block-end: var(--sbb-spacing-fixed-8x);\n}\n\n.sbb-step-label__prefix {\n  position: relative;\n  display: flex;\n  flex-shrink: 0;\n  align-items: center;\n  justify-content: center;\n  width: var(--sbb-step-label-prefix-size);\n  height: var(--sbb-step-label-prefix-size);\n  inset-block-start: calc(1em * var(--sbb-typo-line-height-text) / 2 + var(--sbb-border-width-1x) / 2 - var(--sbb-step-label-prefix-size) / 2);\n}\n.sbb-step-label__prefix::before {\n  content: \"\";\n  position: absolute;\n  inset: calc(var(--sbb-step-label-prefix-size-grow-hover, 0px));\n  border-radius: var(--sbb-border-radius-infinity);\n  border: var(--sbb-border-width-1x) var(--sbb-step-label-prefix-border-style) var(--sbb-step-label-prefix-border-color);\n  background-color: var(--sbb-step-label-prefix-background-color);\n  transition-duration: var(--sbb-step-label-animation-duration);\n  transition-timing-function: var(--sbb-animation-easing);\n  transition-property: background-color, inset;\n}\n\n.sbb-step-label__text {\n  font-weight: bold;\n}\n:host(:is(:state(orientation-horizontal),[state--orientation-horizontal])) .sbb-step-label__text {\n  overflow: hidden;\n  white-space: nowrap;\n  text-overflow: ellipsis;\n}\n\n::slotted(sbb-icon),\nsbb-icon {\n  z-index: 1;\n  background-color: var(--sbb-step-label-prefix-background-color);\n  border-radius: var(--sbb-border-radius-infinity);\n  translate: 0 var(--sbb-step-label-translate-y-content-hover, 0);\n  transition-duration: var(--sbb-step-label-animation-duration);\n  transition-timing-function: var(--sbb-animation-easing);\n  transition-property: background-color, translate;\n}";
+//#endregion
+//#region src/elements/stepper/step-label/step-label.component.ts
+/**
+* Combined with a `sbb-stepper`, it displays a step's label.
+*
+* @slot - Use the unnamed slot to provide a label.
+* @slot icon - Use this to display an icon in the label bubble.
+*/
+var SbbStepLabelElement = class extends SbbIconNameMixin(SbbDisabledMixin(SbbButtonBaseElement)) {
+	static {
+		this.elementName = "sbb-step-label";
+	}
+	static {
+		this.role = "tab";
+	}
+	static {
+		this.styles = [unsafeCSS(step_label_default)];
+	}
+	/** The step controlled by the label. */
+	get step() {
+		return this._step;
+	}
+	get stepper() {
+		return this.closest("sbb-stepper");
+	}
+	set disabled(value) {
+		super.disabled = value;
+		this.toggleState("user-disabled", value);
+	}
+	get disabled() {
+		return super.disabled;
+	}
+	constructor() {
+		super();
+		this._step = null;
+		this._previousSize = null;
+		this.addEventListener?.("click", () => {
+			const stepper = this.stepper;
+			if (stepper && this.step && this._isNotDeactivatedByLinearMode(this.step)) stepper.selected = this.step;
+		});
+		this.addController(new SbbPropertyWatcherController(this, () => this.stepper, {
+			orientation: (s) => {
+				if (this._previousOrientation) this.internals.states.delete(`orientation-${this._previousOrientation}`);
+				this._previousOrientation = s.orientation;
+				if (this._previousOrientation) this.internals.states.add(`orientation-${this._previousOrientation}`);
+			},
+			size: (s) => {
+				if (this._previousSize) this.internals.states.delete(`size-${this._previousSize}`);
+				this._previousSize = s.size;
+				if (this._previousSize) this.internals.states.add(`size-${this._previousSize}`);
+			}
+		}));
+	}
+	_isNotDeactivatedByLinearMode(step) {
+		const stepper = this.stepper;
+		if (stepper?.linear && stepper.selectedIndex !== null) {
+			const index = stepper.steps.indexOf(step);
+			return index < stepper.selectedIndex || index === stepper.selectedIndex + 1;
+		}
+		return true;
+	}
+	connectedCallback() {
+		super.connectedCallback();
+		this.slot ||= "step-label";
+		this.internals.ariaSelected = "false";
+		this.tabIndex = -1;
+		this._assignStep();
+	}
+	/**
+	* Selects and configures the step label.
+	* @internal
+	*/
+	select() {
+		this.tabIndex = 0;
+		this.internals.ariaSelected = "true";
+		this.internals.states.add("selected");
+	}
+	/**
+	* Deselects and configures the step label.
+	* @internal
+	*/
+	deselect() {
+		this.tabIndex = -1;
+		this.internals.ariaSelected = "false";
+		this.internals.states.delete("selected");
+	}
+	/**
+	* Configures the step label.
+	* @internal
+	*/
+	configure(posInSet, setSize, stepperLoaded) {
+		if (stepperLoaded) this._assignStep();
+		this.internals.ariaPosInSet = `${posInSet}`;
+		this.internals.ariaSetSize = `${setSize}`;
+	}
+	_assignStep() {
+		let nextSibling = this.nextElementSibling;
+		while (nextSibling && nextSibling.localName !== "sbb-step") nextSibling = nextSibling.nextElementSibling;
+		const value = nextSibling;
+		this.internals.ariaControlsElements = removeAriaElements(this.internals.ariaControlsElements, this._step);
+		this._step = value instanceof Element ? value : null;
+		this.internals.ariaControlsElements = appendAriaElements(this.internals.ariaControlsElements, this._step);
+	}
+	/**
+	* @internal
+	* Disables the step label and avoids setting the `disabled` state to preserve the initial
+	* disabled state in case of switching between linear and non-linear mode.
+	*/
+	disable(value) {
+		super.disabled = value;
+	}
+	render() {
+		return html`
+      <span class="sbb-step-label__prefix">${this.renderIconSlot()}</span>
+      <span class="sbb-step-label__text"><slot></slot></span>
+    `;
+	}
+};
+//#endregion
+export { SbbStepLabelElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"step-label.component-CpdXVv32.js","names":[],"sources":["../../../src/elements/stepper/step-label/step-label.scss?inline","../../../src/elements/stepper/step-label/step-label.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --sbb-step-label-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-2x)\n  );\n\n  position: relative;\n  display: flex;\n  min-width: 0;\n  max-width: fit-content;\n  gap: var(--sbb-step-label-gap);\n  cursor: var(--sbb-step-label-cursor);\n  color: var(--sbb-step-label-color);\n  font-size: var(--sbb-step-label-font-size);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n  line-height: var(--sbb-typo-line-height-text);\n\n  &::before {\n    @include sbb.absolute-center-x-y;\n\n    font-size: var(--sbb-step-label-number-font-size);\n    font-weight: var(--sbb-step-label-font-weight-selected, normal);\n    inset-block-start: calc(\n      var(--sbb-step-label-font-size) * (var(--sbb-typo-line-height-text) / 2) +\n        (var(--sbb-border-width-1x) / 2)\n    );\n    inset-inline-start: calc(var(--sbb-step-label-prefix-size) / 2);\n    line-height: 1;\n    z-index: 1;\n    translate: -50% calc(-50% + var(--sbb-step-label-translate-y-content-hover, 0px));\n    transition: translate var(--sbb-step-label-animation-duration) var(--sbb-animation-easing);\n  }\n}\n\n:host(:state(selected)) {\n  --sbb-step-label-color: var(--sbb-color-3);\n  --sbb-step-label-font-weight-selected: bold;\n\n  @media (forced-colors: active) {\n    --sbb-step-label-color: Highlight !important;\n  }\n}\n\n:host(:state(size-s)) {\n  --sbb-step-label-gap: var(--sbb-step-label-gap-s);\n  --sbb-step-label-prefix-size: var(--sbb-step-label-prefix-size-s);\n  --sbb-step-label-font-size: var(--sbb-step-label-font-size-s);\n}\n\n:host(:state(size-m)) {\n  --sbb-step-label-gap: var(--sbb-step-label-gap-m);\n  --sbb-step-label-prefix-size: var(--sbb-step-label-prefix-size-m);\n  --sbb-step-label-font-size: var(--sbb-step-label-font-size-m);\n}\n\n:host(:disabled) {\n  --sbb-step-label-color: light-dark(var(--sbb-color-granite), var(--sbb-color-graphite));\n  --sbb-step-label-prefix-border-style: dashed;\n\n  @media (forced-colors: active) {\n    --sbb-step-label-color: GrayText !important;\n  }\n}\n\n:host(:hover:not(:disabled)) {\n  @include sbb.hover-mq($hover: true) {\n    --sbb-step-label-cursor: var(--sbb-cursor-pointer);\n    --sbb-step-label-prefix-background-color: var(--sbb-background-color-3);\n    --sbb-step-label-translate-y-content-hover: #{sbb.px-to-rem-build(-1)};\n    --sbb-step-label-prefix-size-grow-hover: calc(var(--sbb-border-width-2x) * -1);\n  }\n}\n\n:host(:focus-visible) {\n  @include sbb.focus-outline;\n\n  border-radius: var(--sbb-border-radius-1x);\n}\n\n:host(:state(orientation-vertical)) {\n  transition: margin var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n}\n\n:host(:state(orientation-vertical):not(:first-of-type)) {\n  margin-block-start: var(--sbb-spacing-fixed-6x);\n}\n\n:host(:state(selected):state(orientation-vertical)) {\n  margin-block-end: var(--sbb-spacing-fixed-8x);\n}\n\n.sbb-step-label__prefix {\n  position: relative;\n  display: flex;\n  flex-shrink: 0;\n  align-items: center;\n  justify-content: center;\n  width: var(--sbb-step-label-prefix-size);\n  height: var(--sbb-step-label-prefix-size);\n  inset-block-start: calc(\n    1em * (var(--sbb-typo-line-height-text) / 2) + (var(--sbb-border-width-1x) / 2) -\n      (var(--sbb-step-label-prefix-size) / 2)\n  );\n\n  &::before {\n    content: '';\n    position: absolute;\n    inset: calc(var(--sbb-step-label-prefix-size-grow-hover, 0px));\n    border-radius: var(--sbb-border-radius-infinity);\n    border: var(--sbb-border-width-1x) var(--sbb-step-label-prefix-border-style)\n      var(--sbb-step-label-prefix-border-color);\n    background-color: var(--sbb-step-label-prefix-background-color);\n    transition: {\n      duration: var(--sbb-step-label-animation-duration);\n      timing-function: var(--sbb-animation-easing);\n      property: background-color, inset;\n    }\n  }\n}\n\n.sbb-step-label__text {\n  font-weight: bold;\n\n  :host(:state(orientation-horizontal)) & {\n    @include sbb.ellipsis;\n  }\n}\n\n::slotted(sbb-icon),\nsbb-icon {\n  z-index: 1;\n  background-color: var(--sbb-step-label-prefix-background-color);\n  border-radius: var(--sbb-border-radius-infinity);\n  translate: 0 var(--sbb-step-label-translate-y-content-hover, 0);\n  transition: {\n    duration: var(--sbb-step-label-animation-duration);\n    timing-function: var(--sbb-animation-easing);\n    property: background-color, translate;\n  }\n}\n","import { type CSSResultGroup, html, type TemplateResult, unsafeCSS } from 'lit';\n\nimport {\n  appendAriaElements,\n  removeAriaElements,\n  SbbButtonBaseElement,\n  SbbDisabledMixin,\n  SbbPropertyWatcherController,\n} from '../../core.ts';\nimport { SbbIconNameMixin } from '../../icon.pure.ts';\nimport type { SbbStepElement } from '../step/step.component.ts';\nimport type { SbbStepperElement } from '../stepper/stepper.component.ts';\n\nimport style from './step-label.scss?inline';\n\n/**\n * Combined with a `sbb-stepper`, it displays a step's label.\n *\n * @slot - Use the unnamed slot to provide a label.\n * @slot icon - Use this to display an icon in the label bubble.\n */\nexport class SbbStepLabelElement extends SbbIconNameMixin(SbbDisabledMixin(SbbButtonBaseElement)) {\n  public static override readonly elementName: string = 'sbb-step-label';\n  public static override readonly role = 'tab';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n\n  /** The step controlled by the label. */\n  public get step(): SbbStepElement | null {\n    return this._step;\n  }\n  private _step: SbbStepElement | null = null;\n\n  public get stepper(): SbbStepperElement | null {\n    return this.closest('sbb-stepper');\n  }\n\n  public override set disabled(value: boolean) {\n    super.disabled = value;\n\n    // We additionally keep track of the `disabled` state to preserve the user configured disabled state\n    // of step labels in case of switching between linear and non-linear mode.\n    this.toggleState('user-disabled', value);\n  }\n  public override get disabled(): boolean {\n    return super.disabled;\n  }\n\n  private _previousOrientation?: string;\n  private _previousSize: SbbStepperElement['size'] = null;\n\n  public constructor() {\n    super();\n\n    this.addEventListener?.('click', () => {\n      const stepper = this.stepper;\n      if (stepper && this.step && this._isNotDeactivatedByLinearMode(this.step)) {\n        stepper.selected = this.step;\n      }\n    });\n    this.addController(\n      new SbbPropertyWatcherController(this, () => this.stepper, {\n        orientation: (s) => {\n          if (this._previousOrientation) {\n            this.internals.states.delete(`orientation-${this._previousOrientation}`);\n          }\n          this._previousOrientation = s.orientation;\n          if (this._previousOrientation) {\n            this.internals.states.add(`orientation-${this._previousOrientation}`);\n          }\n        },\n        size: (s) => {\n          if (this._previousSize) {\n            this.internals.states.delete(`size-${this._previousSize}`);\n          }\n          this._previousSize = s.size;\n          if (this._previousSize) {\n            this.internals.states.add(`size-${this._previousSize}`);\n          }\n        },\n      }),\n    );\n  }\n\n  private _isNotDeactivatedByLinearMode(step: SbbStepElement): boolean {\n    const stepper = this.stepper;\n    if (stepper?.linear && stepper.selectedIndex !== null) {\n      const index = stepper.steps.indexOf(step);\n      return index < stepper.selectedIndex || index === stepper.selectedIndex + 1;\n    }\n    return true;\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.slot ||= 'step-label';\n    this.internals.ariaSelected = 'false';\n    this.tabIndex = -1;\n    this._assignStep();\n  }\n\n  /**\n   * Selects and configures the step label.\n   * @internal\n   */\n  public select(): void {\n    this.tabIndex = 0;\n    this.internals.ariaSelected = 'true';\n    this.internals.states.add('selected');\n  }\n\n  /**\n   * Deselects and configures the step label.\n   * @internal\n   */\n  public deselect(): void {\n    this.tabIndex = -1;\n    this.internals.ariaSelected = 'false';\n    this.internals.states.delete('selected');\n  }\n\n  /**\n   * Configures the step label.\n   * @internal\n   */\n  public configure(posInSet: number, setSize: number, stepperLoaded: boolean): void {\n    if (stepperLoaded) {\n      this._assignStep();\n    }\n    this.internals.ariaPosInSet = `${posInSet}`;\n    this.internals.ariaSetSize = `${setSize}`;\n  }\n\n  private _assignStep(): void {\n    let nextSibling = this.nextElementSibling;\n    while (nextSibling && nextSibling.localName !== 'sbb-step') {\n      nextSibling = nextSibling.nextElementSibling;\n    }\n\n    const value = nextSibling as SbbStepElement | null;\n    this.internals.ariaControlsElements = removeAriaElements(\n      this.internals.ariaControlsElements,\n      this._step,\n    );\n    this._step = value instanceof Element ? value : null;\n    this.internals.ariaControlsElements = appendAriaElements(\n      this.internals.ariaControlsElements,\n      this._step,\n    );\n  }\n\n  /**\n   * @internal\n   * Disables the step label and avoids setting the `disabled` state to preserve the initial\n   * disabled state in case of switching between linear and non-linear mode.\n   */\n  public disable(value: boolean): void {\n    super.disabled = value;\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <span class=\"sbb-step-label__prefix\">${this.renderIconSlot()}</span>\n      <span class=\"sbb-step-label__text\"><slot></slot></span>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-step-label': SbbStepLabelElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;ACqBA,IAAa,sBAAb,cAAyC,iBAAiB,iBAAiB,oBAAoB,CAAC,EAAC;;EAC/D,KAAA,cAAsB;CAAiB;;EACvC,KAAA,OAAO;CAAM;;EACtB,KAAA,SAAyB,CAAC,UAAU,kBAAK,CAAC;CAAE;;CAGnE,IAAW,OAAI;EACb,OAAO,KAAK;CACd;CAGA,IAAW,UAAO;EAChB,OAAO,KAAK,QAAQ,aAAa;CACnC;CAEA,IAAoB,SAAS,OAAc;EACzC,MAAM,WAAW;EAIjB,KAAK,YAAY,iBAAiB,KAAK;CACzC;CACA,IAAoB,WAAQ;EAC1B,OAAO,MAAM;CACf;CAKA,cAAA;EACE,MAAK;EArBC,KAAA,QAA+B;EAkB/B,KAAA,gBAA2C;EAKjD,KAAK,mBAAmB,eAAc;GACpC,MAAM,UAAU,KAAK;GACrB,IAAI,WAAW,KAAK,QAAQ,KAAK,8BAA8B,KAAK,IAAI,GACtE,QAAQ,WAAW,KAAK;EAE5B,CAAC;EACD,KAAK,cACH,IAAI,6BAA6B,YAAY,KAAK,SAAS;GACzD,cAAc,MAAK;IACjB,IAAI,KAAK,sBACP,KAAK,UAAU,OAAO,OAAO,eAAe,KAAK,sBAAsB;IAEzE,KAAK,uBAAuB,EAAE;IAC9B,IAAI,KAAK,sBACP,KAAK,UAAU,OAAO,IAAI,eAAe,KAAK,sBAAsB;GAExE;GACA,OAAO,MAAK;IACV,IAAI,KAAK,eACP,KAAK,UAAU,OAAO,OAAO,QAAQ,KAAK,eAAe;IAE3D,KAAK,gBAAgB,EAAE;IACvB,IAAI,KAAK,eACP,KAAK,UAAU,OAAO,IAAI,QAAQ,KAAK,eAAe;GAE1D;GACD,CAAC;CAEN;CAEQ,8BAA8B,MAAoB;EACxD,MAAM,UAAU,KAAK;EACrB,IAAI,SAAS,UAAU,QAAQ,kBAAkB,MAAM;GACrD,MAAM,QAAQ,QAAQ,MAAM,QAAQ,IAAI;GACxC,OAAO,QAAQ,QAAQ,iBAAiB,UAAU,QAAQ,gBAAgB;EAC5E;EACA,OAAO;CACT;CAEgB,oBAAiB;EAC/B,MAAM,kBAAiB;EACvB,KAAK,SAAS;EACd,KAAK,UAAU,eAAe;EAC9B,KAAK,WAAW;EAChB,KAAK,YAAW;CAClB;;;;;CAMO,SAAM;EACX,KAAK,WAAW;EAChB,KAAK,UAAU,eAAe;EAC9B,KAAK,UAAU,OAAO,IAAI,UAAU;CACtC;;;;;CAMO,WAAQ;EACb,KAAK,WAAW;EAChB,KAAK,UAAU,eAAe;EAC9B,KAAK,UAAU,OAAO,OAAO,UAAU;CACzC;;;;;CAMO,UAAU,UAAkB,SAAiB,eAAsB;EACxE,IAAI,eACF,KAAK,YAAW;EAElB,KAAK,UAAU,eAAe,GAAG;EACjC,KAAK,UAAU,cAAc,GAAG;CAClC;CAEQ,cAAW;EACjB,IAAI,cAAc,KAAK;EACvB,OAAO,eAAe,YAAY,cAAc,YAC9C,cAAc,YAAY;EAG5B,MAAM,QAAQ;EACd,KAAK,UAAU,uBAAuB,mBACpC,KAAK,UAAU,sBACf,KAAK,KAAK;EAEZ,KAAK,QAAQ,iBAAiB,UAAU,QAAQ;EAChD,KAAK,UAAU,uBAAuB,mBACpC,KAAK,UAAU,sBACf,KAAK,KAAK;CAEd;;;;;;CAOO,QAAQ,OAAc;EAC3B,MAAM,WAAW;CACnB;CAEmB,SAAM;EACvB,OAAO,IAAI;6CAC8B,KAAK,eAAc,EAAE;;;CAGhE"}