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

package/development/stepper.component-80S-oXrH.js

@@ -0,0 +1,422 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement, SbbMediaMatcherController, SbbMediaQueryBreakpointLargeAndAbove, SbbMediaQueryBreakpointSmallAndAbove, SbbMediaQueryBreakpointUltraAndAbove, SbbMediaQueryBreakpointZeroAndAbove, forceType, getNextElementIndex, isArrowKeyPressed } from "./core.js";
+import { IntersectionController } from "@lit-labs/observers/intersection-controller.js";
+//#region src/elements/stepper/stepper/stepper.scss?inline
+var stepper_default = ":host {\n  --sbb-stepper-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n  display: block;\n  position: relative;\n  counter-reset: step-label;\n}\n@media (forced-colors: active) {\n  :host {\n    --sbb-stepper-marker-color: ButtonText;\n  }\n}\n\n:host(:is(:state(disable-animation),[state--disable-animation])) {\n  --sbb-disable-animation-duration: 0s;\n}\n\n:host([orientation=vertical]) {\n  --sbb-stepper-orientation: column;\n}\n\n.sbb-stepper__labels {\n  display: flex;\n  flex-direction: var(--sbb-stepper-orientation);\n  position: relative;\n  justify-content: start;\n  margin-block-end: var(--sbb-spacing-responsive-m);\n}\n.sbb-stepper__labels::before {\n  content: \"\";\n  position: absolute;\n  inset-inline-start: calc(var(--sbb-stepper-border-width) * -1);\n  background-color: var(--sbb-stepper-marker-color);\n}\n:host([orientation=horizontal]) .sbb-stepper__labels {\n  gap: var(--sbb-spacing-responsive-m);\n  padding-block-end: var(--sbb-spacing-fixed-4x);\n  border-block-end: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);\n}\n:host([orientation=horizontal]) .sbb-stepper__labels::before {\n  inset-block-end: calc(var(--sbb-stepper-border-width) * -1);\n  height: var(--sbb-stepper-marker-width);\n  width: var(--sbb-stepper-marker-size, 0);\n  transition: width var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n}\n:host([orientation=vertical]) .sbb-stepper__labels {\n  padding-inline-start: var(--sbb-spacing-fixed-4x);\n  border-inline-start: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);\n}\n:host([orientation=vertical]) .sbb-stepper__labels::before {\n  inset-block-start: 0;\n  width: var(--sbb-stepper-marker-width);\n  height: var(--sbb-stepper-marker-size, 0);\n  transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n}\n\n.sbb-stepper__steps {\n  position: relative;\n}\n:host([orientation=horizontal]) .sbb-stepper__steps {\n  height: var(--sbb-stepper-content-height);\n  transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n}\n\n::slotted(sbb-step-label)::before {\n  content: counter(step-label);\n  counter-increment: step-label;\n}";
+//#endregion
+//#region src/elements/stepper/stepper/stepper.component.ts
+var DEBOUNCE_TIME = 150;
+var breakpointMap = {
+	zero: SbbMediaQueryBreakpointZeroAndAbove,
+	small: SbbMediaQueryBreakpointSmallAndAbove,
+	large: SbbMediaQueryBreakpointLargeAndAbove,
+	ultra: SbbMediaQueryBreakpointUltraAndAbove
+};
+var SbbStepChangeEvent = class extends Event {
+	constructor(selectedIndex, previousIndex, selectedStep, previousStep) {
+		super("stepchange", {
+			bubbles: true,
+			composed: true
+		});
+		this.selectedIndex = selectedIndex;
+		this.previousIndex = previousIndex;
+		this.selectedStep = selectedStep;
+		this.previousStep = previousStep;
+	}
+};
+/**
+* Provides a structured, step-by-step workflow for user interactions.
+* @slot - Provide a `sbb-expansion-panel-header` and a `sbb-expansion-panel-content` to the stepper.
+* @slot step-label - Use this slot to provide an `sbb-step-label`.
+* @slot step - Use this slot to provide an `sbb-step`.
+* @event {SbbStepChangeEvent} stepchange - Emits whenever a step was changed.
+*/
+var SbbStepperElement = (() => {
+	let _classSuper = SbbElement;
+	let _instanceExtraInitializers = [];
+	let _linear_decorators;
+	let _linear_initializers = [];
+	let _linear_extraInitializers = [];
+	let _set_horizontalFrom_decorators;
+	let _orientation_decorators;
+	let _orientation_initializers = [];
+	let _orientation_extraInitializers = [];
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	let _set_selected_decorators;
+	let _set_selectedIndex_decorators;
+	return class SbbStepperElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_linear_decorators = [forceType(), property({ type: Boolean })];
+			_set_horizontalFrom_decorators = [property({
+				attribute: "horizontal-from",
+				reflect: true
+			})];
+			_orientation_decorators = [property({ reflect: true })];
+			_size_decorators = [property({ reflect: true })];
+			_set_selected_decorators = [property({ attribute: false })];
+			_set_selectedIndex_decorators = [property({
+				attribute: "selected-index",
+				type: Number
+			})];
+			__esDecorate(this, null, _linear_decorators, {
+				kind: "accessor",
+				name: "linear",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "linear" in obj,
+					get: (obj) => obj.linear,
+					set: (obj, value) => {
+						obj.linear = value;
+					}
+				},
+				metadata: _metadata
+			}, _linear_initializers, _linear_extraInitializers);
+			__esDecorate(this, null, _set_horizontalFrom_decorators, {
+				kind: "setter",
+				name: "horizontalFrom",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "horizontalFrom" in obj,
+					set: (obj, value) => {
+						obj.horizontalFrom = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _orientation_decorators, {
+				kind: "accessor",
+				name: "orientation",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "orientation" in obj,
+					get: (obj) => obj.orientation,
+					set: (obj, value) => {
+						obj.orientation = value;
+					}
+				},
+				metadata: _metadata
+			}, _orientation_initializers, _orientation_extraInitializers);
+			__esDecorate(this, null, _size_decorators, {
+				kind: "accessor",
+				name: "size",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "size" in obj,
+					get: (obj) => obj.size,
+					set: (obj, value) => {
+						obj.size = value;
+					}
+				},
+				metadata: _metadata
+			}, _size_initializers, _size_extraInitializers);
+			__esDecorate(this, null, _set_selected_decorators, {
+				kind: "setter",
+				name: "selected",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "selected" in obj,
+					set: (obj, value) => {
+						obj.selected = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_selectedIndex_decorators, {
+				kind: "setter",
+				name: "selectedIndex",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "selectedIndex" in obj,
+					set: (obj, value) => {
+						obj.selectedIndex = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-stepper";
+		}
+		static {
+			this.styles = [unsafeCSS(stepper_default)];
+		}
+		static {
+			this.events = { stepchange: "stepchange" };
+		}
+		#linear_accessor_storage;
+		/** If set to true, only the current and previous labels can be clicked and selected. */
+		get linear() {
+			return this.#linear_accessor_storage;
+		}
+		set linear(value) {
+			this.#linear_accessor_storage = value;
+		}
+		/** Overrides the behavior of `orientation` property. */
+		set horizontalFrom(value) {
+			this._horizontalFrom = value && breakpointMap[value] ? value : null;
+			if (this._horizontalFrom && this._loaded) this._checkOrientation();
+		}
+		get horizontalFrom() {
+			return this._horizontalFrom;
+		}
+		#orientation_accessor_storage;
+		/** Steps orientation, either horizontal or vertical. */
+		get orientation() {
+			return this.#orientation_accessor_storage;
+		}
+		set orientation(value) {
+			this.#orientation_accessor_storage = value;
+		}
+		#size_accessor_storage;
+		/**
+		* Size variant, either s (lean theme default) or m (standard theme default).
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		/** The currently selected step. */
+		set selected(step) {
+			if (this._loaded) this._select(step);
+			this._requestedSelected = step;
+		}
+		get selected() {
+			return this.querySelector?.("sbb-step:is(:state(selected),[state--selected])") ?? null;
+		}
+		/** The currently selected step index. */
+		set selectedIndex(index) {
+			if (this._loaded && index !== null) this._select(this.steps[index]);
+			this._requestedSelectedIndex = index;
+		}
+		get selectedIndex() {
+			return this.selected ? this.steps.indexOf(this.selected) : null;
+		}
+		/** The steps of the stepper. */
+		get steps() {
+			const steps = [];
+			this.querySelectorAll?.("sbb-step").forEach((step) => {
+				customElements.upgrade(step);
+				steps.push(step);
+			});
+			return steps;
+		}
+		get _enabledSteps() {
+			return this.steps.filter((s) => {
+				if (s.label) {
+					customElements.upgrade(s.label);
+					return !s.label.disabled;
+				}
+				return false;
+			});
+		}
+		constructor() {
+			super();
+			/**
+			* If the sbb-stepper is used in a sbb-dialog, the marker on the selected element will not appear,
+			* because the calculations are done when the dialog is closed, so the marker has a width of 0;
+			* the same happens for the stepper height.
+			* We need to recalculate it when the element becomes visible.
+			*/
+			this._observer = (__runInitializers(this, _instanceExtraInitializers), new IntersectionController(this, {
+				target: null,
+				callback: (entries) => {
+					entries.forEach((e) => {
+						if (e.intersectionRatio > 0) {
+							this._setStepperHeight(this.selected);
+							this._setMarkerSize();
+						}
+					});
+				}
+			}));
+			this.#linear_accessor_storage = __runInitializers(this, _linear_initializers, false);
+			this._horizontalFrom = (__runInitializers(this, _linear_extraInitializers), null);
+			this.#orientation_accessor_storage = __runInitializers(this, _orientation_initializers, "horizontal");
+			this.#size_accessor_storage = (__runInitializers(this, _orientation_extraInitializers), __runInitializers(this, _size_initializers, null));
+			this._requestedSelected = (__runInitializers(this, _size_extraInitializers), null);
+			this._requestedSelectedIndex = null;
+			this._loaded = false;
+			this._resizeObserverTimeout = null;
+			this._mediaMatcher = new SbbMediaMatcherController(this, {});
+			this._onStepperResize = () => {
+				this._checkOrientation();
+				this._setStepperHeight(this.selected);
+				clearTimeout(this._resizeObserverTimeout);
+				this.internals.states.add("disable-animation");
+				this._resizeObserverTimeout = setTimeout(() => this.internals.states.delete("disable-animation"), DEBOUNCE_TIME);
+			};
+			this.addEventListener?.("keydown", (e) => this._handleKeyDown(e));
+			this.addEventListener?.("resizechange", (e) => this._onSelectedStepResize(e));
+		}
+		/** Selects the next step. */
+		next() {
+			if (this.selectedIndex !== null) this._select(this.steps[this.selectedIndex + 1]);
+		}
+		/** Selects the previous step. */
+		previous() {
+			if (this.selectedIndex !== null) this._select(this.steps[this.selectedIndex - 1]);
+		}
+		/** Resets the form in which the stepper is nested or every form of each step, if any. */
+		reset() {
+			const closestForm = this.closest("form");
+			if (closestForm) closestForm.reset();
+			else this.querySelectorAll("form").forEach((form) => form.reset());
+			this.selectedIndex = 0;
+			if (document.activeElement?.closest("sbb-stepper") === this) this.selected?.label?.focus();
+		}
+		_isSelectable(step) {
+			if (step) {
+				customElements.upgrade(step);
+				if (step.label) {
+					customElements.upgrade(step.label);
+					if (!this.linear && step.label.disabled) return false;
+				}
+				return true;
+			} else return false;
+		}
+		_select(step) {
+			if (!this._isSelectable(step) || step === this.selected) return;
+			const currentIndex = this.selectedIndex;
+			const currentStep = this.selected;
+			const validatePayload = {
+				currentIndex,
+				currentStep,
+				nextIndex: this.selectedIndex !== null ? this.selectedIndex + 1 : null,
+				nextStep: this.selectedIndex !== null ? this.steps[this.selectedIndex + 1] : null
+			};
+			if (this.selected && !this.selected.validate(validatePayload)) return;
+			this.selected?.deselect();
+			step.select();
+			/** @internal only to provide double entry in docs. It is a public event! */
+			this.dispatchEvent(new SbbStepChangeEvent(this.selectedIndex, currentIndex, this.selected, currentStep));
+			this._setMarkerSize();
+			this._setStepperHeight(step);
+			this._configureLinearMode();
+			if (document.activeElement?.closest("sbb-stepper") === this) this.selected?.label?.focus();
+		}
+		_setMarkerSize() {
+			if (!this._loaded || !this.selected || this.selectedIndex === void 0 || !this.selected.label) return;
+			const offset = this.orientation === "horizontal" ? this.selected.label.offsetLeft + this.selected.label.offsetWidth : this._calculateLabelOffsetTop();
+			this.style.setProperty("--sbb-stepper-marker-size", `${offset}px`);
+		}
+		/**
+		* Sets the stepper height based on the height of the provided step.
+		*/
+		_setStepperHeight(step) {
+			if (step && step.shadowRoot) {
+				const innerElement = step.shadowRoot.querySelector(".sbb-step");
+				if (innerElement) this.style?.setProperty("--sbb-stepper-content-height", `${innerElement.offsetHeight}px`);
+			}
+		}
+		_calculateLabelOffsetTop() {
+			if (this.selectedIndex === null) return;
+			let offset = 0;
+			for (const step of this.steps) {
+				if (step === this.selected) break;
+				offset = step.label.offsetHeight + offset;
+			}
+			return offset + this.selected.label.offsetHeight + parseFloat(getComputedStyle(this).getPropertyValue("--sbb-spacing-fixed-6x")) * 16 * this.selectedIndex;
+		}
+		_onSelectedStepResize(e) {
+			this._setStepperHeight(e.target);
+		}
+		_configure() {
+			this.steps.forEach((step, i, array) => {
+				step.configure(this._loaded);
+				step.label?.configure(i + 1, array.length, this._loaded);
+			});
+			this._select(this.selected || this._enabledSteps[0]);
+		}
+		_updateLabels() {
+			this.steps.forEach((step) => {
+				step.slot = this.orientation === "horizontal" ? "step" : "step-label";
+			});
+		}
+		_checkOrientation() {
+			if (this.horizontalFrom) {
+				this.orientation = this._mediaMatcher.matches(breakpointMap[this.horizontalFrom]) ? "horizontal" : "vertical";
+				this._updateLabels();
+			}
+			setTimeout(() => this._setMarkerSize(), 0);
+		}
+		_configureLinearMode() {
+			this.steps.forEach((step, index) => {
+				if (!step.label) return;
+				customElements.upgrade(step.label);
+				step.label.disable(this.linear && index > this.selectedIndex || !this.linear && step.label.matches(":is(:state(user-disabled),[state--user-disabled])"));
+			});
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			window.addEventListener("resize", this._onStepperResize, { passive: true });
+			this.toggleState("disable-animation", !this._loaded);
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			window.removeEventListener("resize", this._onStepperResize);
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this.updateComplete.then(() => {
+				this._loaded = true;
+				this._configure();
+				if (this._requestedSelected && this.steps.indexOf(this._requestedSelected) !== -1) this.selectedIndex = this.steps.indexOf(this._requestedSelected);
+				else if (this._requestedSelectedIndex) this.selectedIndex = this._requestedSelectedIndex;
+				else this.selectedIndex = 0;
+				this._observer.observe(this);
+				this._checkOrientation();
+				setTimeout(() => this.internals.states.delete("disable-animation"), DEBOUNCE_TIME);
+			});
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("orientation") && !this.horizontalFrom) {
+				this._updateLabels();
+				this._setMarkerSize();
+			}
+			if (changedProperties.has("linear") && this._loaded) this._configureLinearMode();
+			if (changedProperties.has("size")) this._setMarkerSize();
+		}
+		_handleKeyDown(evt) {
+			const enabledSteps = this._enabledSteps;
+			if (!enabledSteps || evt.target !== this && evt.target.parentElement !== this) return;
+			if (isArrowKeyPressed(evt)) {
+				const nextIndex = getNextElementIndex(evt, enabledSteps.indexOf(this.selected), enabledSteps.length);
+				this._select(enabledSteps[nextIndex]);
+				evt.preventDefault();
+			}
+		}
+		render() {
+			return html`
+      <div class="sbb-stepper__labels" role="tablist">
+        <slot name="step-label" @slotchange=${this._configure}></slot>
+      </div>
+      <div class="sbb-stepper__steps">
+        <slot name="step" @slotchange=${this._configure}></slot>
+      </div>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbStepperElement as n, SbbStepChangeEvent as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"stepper.component-80S-oXrH.js","names":[],"sources":["../../../src/elements/stepper/stepper/stepper.scss?inline","../../../src/elements/stepper/stepper/stepper.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --sbb-stepper-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n\n  display: block;\n  position: relative;\n  counter-reset: step-label;\n\n  @include sbb.if-forced-colors {\n    --sbb-stepper-marker-color: ButtonText;\n  }\n}\n\n:host(:state(disable-animation)) {\n  @include sbb.disable-animation;\n}\n\n:host([orientation='vertical']) {\n  --sbb-stepper-orientation: column;\n}\n\n.sbb-stepper__labels {\n  display: flex;\n  flex-direction: var(--sbb-stepper-orientation);\n  position: relative;\n  justify-content: start;\n  margin-block-end: var(--sbb-spacing-responsive-m);\n\n  &::before {\n    content: '';\n    position: absolute;\n    inset-inline-start: calc(var(--sbb-stepper-border-width) * -1);\n    background-color: var(--sbb-stepper-marker-color);\n  }\n\n  :host([orientation='horizontal']) & {\n    gap: var(--sbb-spacing-responsive-m);\n    padding-block-end: var(--sbb-spacing-fixed-4x);\n    border-block-end: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);\n\n    &::before {\n      inset-block-end: calc(var(--sbb-stepper-border-width) * -1);\n      height: var(--sbb-stepper-marker-width);\n      width: var(--sbb-stepper-marker-size, 0);\n      transition: width var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n    }\n  }\n\n  :host([orientation='vertical']) & {\n    padding-inline-start: var(--sbb-spacing-fixed-4x);\n    border-inline-start: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);\n\n    &::before {\n      inset-block-start: 0;\n      width: var(--sbb-stepper-marker-width);\n      height: var(--sbb-stepper-marker-size, 0);\n      transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n    }\n  }\n}\n\n.sbb-stepper__steps {\n  position: relative;\n\n  :host([orientation='horizontal']) & {\n    height: var(--sbb-stepper-content-height);\n    transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n  }\n}\n\n::slotted(sbb-step-label)::before {\n  content: counter(step-label);\n  counter-increment: step-label;\n}\n","import { IntersectionController } from '@lit-labs/observers/intersection-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport type { SbbHorizontalFrom } from '../../core.ts';\nimport {\n  forceType,\n  getNextElementIndex,\n  isArrowKeyPressed,\n  SbbElement,\n  SbbMediaMatcherController,\n  SbbMediaQueryBreakpointLargeAndAbove,\n  SbbMediaQueryBreakpointSmallAndAbove,\n  SbbMediaQueryBreakpointUltraAndAbove,\n  SbbMediaQueryBreakpointZeroAndAbove,\n} from '../../core.ts';\nimport type { SbbStepElement, SbbStepValidateEventDetails } from '../step/step.component.ts';\n\nimport style from './stepper.scss?inline';\n\nconst DEBOUNCE_TIME = 150;\n\nconst breakpointMap: Record<string, string> = {\n  zero: SbbMediaQueryBreakpointZeroAndAbove,\n  small: SbbMediaQueryBreakpointSmallAndAbove,\n  large: SbbMediaQueryBreakpointLargeAndAbove,\n  ultra: SbbMediaQueryBreakpointUltraAndAbove,\n};\n\nexport class SbbStepChangeEvent extends Event {\n  /** The index of the newly selected step. */\n  public readonly selectedIndex: number | null;\n\n  /** The index of the previously selected step. */\n  public readonly previousIndex: number | null;\n\n  /** The newly selected step element. */\n  public readonly selectedStep: SbbStepElement | null;\n\n  /** The previously selected step element. */\n  public readonly previousStep: SbbStepElement | null;\n\n  public constructor(\n    selectedIndex: number | null,\n    previousIndex: number | null,\n    selectedStep: SbbStepElement | null,\n    previousStep: SbbStepElement | null,\n  ) {\n    super('stepchange', { bubbles: true, composed: true });\n    this.selectedIndex = selectedIndex;\n    this.previousIndex = previousIndex;\n    this.selectedStep = selectedStep;\n    this.previousStep = previousStep;\n  }\n}\n/**\n * Provides a structured, step-by-step workflow for user interactions.\n * @slot - Provide a `sbb-expansion-panel-header` and a `sbb-expansion-panel-content` to the stepper.\n * @slot step-label - Use this slot to provide an `sbb-step-label`.\n * @slot step - Use this slot to provide an `sbb-step`.\n * @event {SbbStepChangeEvent} stepchange - Emits whenever a step was changed.\n */\nexport class SbbStepperElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-stepper';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n  public static readonly events = {\n    stepchange: 'stepchange',\n  } as const;\n\n  /**\n   * If the sbb-stepper is used in a sbb-dialog, the marker on the selected element will not appear,\n   * because the calculations are done when the dialog is closed, so the marker has a width of 0;\n   * the same happens for the stepper height.\n   * We need to recalculate it when the element becomes visible.\n   */\n  private _observer = new IntersectionController(this, {\n    target: null,\n    callback: (entries) => {\n      entries.forEach((e) => {\n        if (e.intersectionRatio > 0) {\n          this._setStepperHeight(this.selected);\n          this._setMarkerSize();\n        }\n      });\n    },\n  });\n\n  /** If set to true, only the current and previous labels can be clicked and selected. */\n  @forceType()\n  @property({ type: Boolean })\n  public accessor linear: boolean = false;\n\n  /** Overrides the behavior of `orientation` property. */\n  @property({ attribute: 'horizontal-from', reflect: true })\n  public set horizontalFrom(value: SbbHorizontalFrom | null) {\n    this._horizontalFrom = value && breakpointMap[value] ? value : null;\n    if (this._horizontalFrom && this._loaded) {\n      this._checkOrientation();\n    }\n  }\n  public get horizontalFrom(): SbbHorizontalFrom | null {\n    return this._horizontalFrom;\n  }\n  private _horizontalFrom: SbbHorizontalFrom | null = null;\n\n  /** Steps orientation, either horizontal or vertical. */\n  @property({ reflect: true })\n  public accessor orientation: 'horizontal' | 'vertical' = 'horizontal';\n\n  /**\n   * Size variant, either s (lean theme default) or m (standard theme default).\n   */\n  @property({ reflect: true }) public accessor size: 's' | 'm' | null = null;\n\n  /** The currently selected step. */\n  @property({ attribute: false })\n  public set selected(step: SbbStepElement | null) {\n    if (this._loaded) {\n      this._select(step);\n    }\n    this._requestedSelected = step;\n  }\n  public get selected(): SbbStepElement | null {\n    return this.querySelector?.<SbbStepElement>('sbb-step:state(selected)') ?? null;\n  }\n  private _requestedSelected: SbbStepElement | null = null;\n\n  /** The currently selected step index. */\n  @property({ attribute: 'selected-index', type: Number })\n  public set selectedIndex(index: number | null) {\n    if (this._loaded && index !== null) {\n      this._select(this.steps[index]);\n    }\n    this._requestedSelectedIndex = index;\n  }\n  public get selectedIndex(): number | null {\n    return this.selected ? this.steps.indexOf(this.selected) : null;\n  }\n  private _requestedSelectedIndex: number | null = null;\n\n  /** The steps of the stepper. */\n  public get steps(): SbbStepElement[] {\n    const steps: SbbStepElement[] = [];\n    this.querySelectorAll?.('sbb-step').forEach((step) => {\n      customElements.upgrade(step);\n      steps.push(step);\n    });\n    return steps;\n  }\n\n  private get _enabledSteps(): SbbStepElement[] {\n    return this.steps.filter((s) => {\n      if (s.label) {\n        customElements.upgrade(s.label);\n        return !s.label.disabled;\n      }\n      return false;\n    });\n  }\n\n  private _loaded: boolean = false;\n  private _resizeObserverTimeout: ReturnType<typeof setTimeout> | null = null;\n  private _mediaMatcher = new SbbMediaMatcherController(this, {});\n\n  public constructor() {\n    super();\n    this.addEventListener?.('keydown', (e) => this._handleKeyDown(e));\n    this.addEventListener?.('resizechange', (e: Event) => this._onSelectedStepResize(e));\n  }\n\n  /** Selects the next step. */\n  public next(): void {\n    if (this.selectedIndex !== null) {\n      this._select(this.steps[this.selectedIndex + 1]);\n    }\n  }\n\n  /** Selects the previous step. */\n  public previous(): void {\n    if (this.selectedIndex !== null) {\n      this._select(this.steps[this.selectedIndex - 1]);\n    }\n  }\n\n  /** Resets the form in which the stepper is nested or every form of each step, if any. */\n  public reset(): void {\n    const closestForm = this.closest('form');\n    if (closestForm) {\n      closestForm.reset();\n    } else {\n      this.querySelectorAll('form').forEach((form) => form.reset());\n    }\n    this.selectedIndex = 0;\n    // In case the focus is currently inside the stepper, we reset the focus to the first/selected step label.\n    if (document.activeElement?.closest('sbb-stepper') === this) {\n      this.selected?.label?.focus();\n    }\n  }\n\n  private _isSelectable(step: SbbStepElement | null): step is SbbStepElement {\n    if (step) {\n      customElements.upgrade(step);\n      if (step.label) {\n        customElements.upgrade(step.label);\n        if (!this.linear && step.label.disabled) {\n          return false;\n        }\n      }\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  private _select(step: SbbStepElement | null): void {\n    if (!this._isSelectable(step) || step === this.selected) {\n      return;\n    }\n    const currentIndex = this.selectedIndex;\n    const currentStep = this.selected;\n    const validatePayload: SbbStepValidateEventDetails = {\n      currentIndex,\n      currentStep,\n      nextIndex: this.selectedIndex !== null ? this.selectedIndex + 1 : null,\n      nextStep: this.selectedIndex !== null ? this.steps[this.selectedIndex + 1] : null,\n    };\n\n    if (this.selected && !this.selected.validate(validatePayload)) {\n      return;\n    }\n\n    const current = this.selected;\n    current?.deselect();\n    step.select();\n\n    /** @internal only to provide double entry in docs. It is a public event! */\n    this.dispatchEvent(\n      new SbbStepChangeEvent(this.selectedIndex, currentIndex, this.selected, currentStep),\n    );\n\n    this._setMarkerSize();\n    this._setStepperHeight(step);\n    this._configureLinearMode();\n    // In case the focus is currently inside the stepper, we focus the selected step label.\n    if (document.activeElement?.closest('sbb-stepper') === this) {\n      this.selected?.label?.focus();\n    }\n  }\n\n  private _setMarkerSize(): void {\n    if (\n      !this._loaded ||\n      !this.selected ||\n      this.selectedIndex === undefined ||\n      !this.selected.label\n    ) {\n      return;\n    }\n    const offset =\n      this.orientation === 'horizontal'\n        ? this.selected.label.offsetLeft + this.selected.label.offsetWidth\n        : this._calculateLabelOffsetTop();\n\n    this.style.setProperty('--sbb-stepper-marker-size', `${offset}px`);\n  }\n\n  /**\n   * Sets the stepper height based on the height of the provided step.\n   */\n  private _setStepperHeight(step: SbbStepElement | null): void {\n    if (step && step.shadowRoot) {\n      const innerElement: SbbStepElement | null = step.shadowRoot.querySelector('.sbb-step');\n      if (innerElement) {\n        this.style?.setProperty('--sbb-stepper-content-height', `${innerElement.offsetHeight}px`);\n      }\n    }\n  }\n\n  private _calculateLabelOffsetTop(): number | undefined {\n    if (this.selectedIndex === null) {\n      return;\n    }\n    let offset = 0;\n    for (const step of this.steps) {\n      if (step === this.selected) {\n        break;\n      }\n      offset = step.label!.offsetHeight + offset;\n    }\n    return (\n      offset +\n      this.selected!.label!.offsetHeight! +\n      parseFloat(getComputedStyle(this).getPropertyValue('--sbb-spacing-fixed-6x')) *\n        16 *\n        this.selectedIndex\n    );\n  }\n\n  private _onSelectedStepResize(e: Event): void {\n    this._setStepperHeight(e.target as SbbStepElement);\n  }\n\n  private _configure(): void {\n    this.steps.forEach((step, i, array) => {\n      step.configure(this._loaded);\n      step.label?.configure(i + 1, array.length, this._loaded);\n    });\n    this._select(this.selected || this._enabledSteps[0]);\n  }\n\n  private _updateLabels(): void {\n    this.steps.forEach((step) => {\n      step.slot = this.orientation === 'horizontal' ? 'step' : 'step-label';\n    });\n  }\n\n  private _checkOrientation(): void {\n    if (this.horizontalFrom) {\n      this.orientation = this._mediaMatcher.matches(breakpointMap[this.horizontalFrom])\n        ? 'horizontal'\n        : 'vertical';\n      this._updateLabels();\n    }\n    // The timeout is needed to make sure that the marker takes the correct step-label size.\n    setTimeout(() => this._setMarkerSize(), 0);\n  }\n\n  private _onStepperResize = (): void => {\n    this._checkOrientation();\n    this._setStepperHeight(this.selected);\n    clearTimeout(this._resizeObserverTimeout!);\n    this.internals.states.add('disable-animation');\n\n    // Disable the animation when resizing to avoid strange transition effects.\n    this._resizeObserverTimeout = setTimeout(\n      () => this.internals.states.delete('disable-animation'),\n      DEBOUNCE_TIME,\n    );\n  };\n\n  private _configureLinearMode(): void {\n    this.steps.forEach((step, index) => {\n      if (!step.label) {\n        return;\n      }\n      customElements.upgrade(step.label);\n\n      step.label.disable(\n        (this.linear && index > this.selectedIndex!) ||\n          (!this.linear && step.label.matches(':state(user-disabled)')),\n      );\n    });\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    window.addEventListener('resize', this._onStepperResize, {\n      passive: true,\n    });\n    this.toggleState('disable-animation', !this._loaded);\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    window.removeEventListener('resize', this._onStepperResize);\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this.updateComplete.then(() => {\n      this._loaded = true;\n      this._configure();\n\n      if (this._requestedSelected && this.steps.indexOf(this._requestedSelected) !== -1) {\n        this.selectedIndex = this.steps.indexOf(this._requestedSelected);\n      } else if (this._requestedSelectedIndex) {\n        this.selectedIndex = this._requestedSelectedIndex;\n      } else {\n        this.selectedIndex = 0;\n      }\n\n      this._observer.observe(this);\n      this._checkOrientation();\n      // Remove disable-animation state after component init\n      setTimeout(() => this.internals.states.delete('disable-animation'), DEBOUNCE_TIME);\n    });\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n    if (changedProperties.has('orientation') && !this.horizontalFrom) {\n      this._updateLabels();\n      this._setMarkerSize();\n    }\n    if (changedProperties.has('linear') && this._loaded) {\n      this._configureLinearMode();\n    }\n\n    if (changedProperties.has('size')) {\n      this._setMarkerSize();\n    }\n  }\n\n  private _handleKeyDown(evt: KeyboardEvent): void {\n    const enabledSteps: SbbStepElement[] = this._enabledSteps;\n\n    if (\n      !enabledSteps ||\n      // don't trap nested handling\n      ((evt.target as HTMLElement) !== this && (evt.target as HTMLElement).parentElement !== this)\n    ) {\n      return;\n    }\n\n    if (isArrowKeyPressed(evt)) {\n      const current: number = enabledSteps.indexOf(this.selected!);\n      const nextIndex: number = getNextElementIndex(evt, current, enabledSteps.length);\n      this._select(enabledSteps[nextIndex]);\n      evt.preventDefault();\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-stepper__labels\" role=\"tablist\">\n        <slot name=\"step-label\" @slotchange=${this._configure}></slot>\n      </div>\n      <div class=\"sbb-stepper__steps\">\n        <slot name=\"step\" @slotchange=${this._configure}></slot>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-stepper': SbbStepperElement;\n  }\n}\n"],"mappings":"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"}

package/development/stepper.js

@@ -1,6 +1,6 @@
-import { t as SbbStepLabelElement } from "./step-label.component-BpuNDWKl.js";
-import { t as SbbStepElement } from "./step.component-Di2fT-VG.js";
-import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-BnCUoYv6.js";
+import { t as SbbStepLabelElement } from "./step-label.component-Bo7Z0w7N.js";
+import { t as SbbStepElement } from "./step.component-CcjtUFyR.js";
+import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-80S-oXrH.js";
 import "./stepper.pure.js";
 //#region src/elements/stepper.ts
 /** @entrypoint */

package/development/stepper.pure.js

@@ -1,4 +1,4 @@
-import { t as SbbStepLabelElement } from "./step-label.component-BpuNDWKl.js";
-import { t as SbbStepElement } from "./step.component-Di2fT-VG.js";
-import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-BnCUoYv6.js";
+import { t as SbbStepLabelElement } from "./step-label.component-Bo7Z0w7N.js";
+import { t as SbbStepElement } from "./step.component-CcjtUFyR.js";
+import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-80S-oXrH.js";
 export { SbbStepChangeEvent, SbbStepElement, SbbStepLabelElement, SbbStepperElement };