@sbb-esta/lyne-elements-dev 4.7.0-dev.1773388991 → 4.7.0-dev.1773393164

package/development/stepper/stepper/stepper.component.js

@@ -1,2 +1,465 @@
-import { n as SbbStepperElement, t as SbbStepChangeEvent } from "../../stepper.component-D1tAcpWs.js";
-export { SbbStepChangeEvent, SbbStepperElement };
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __esDecorate, __runInitializers } from "tslib";
+import { IntersectionController } from "@lit-labs/observers/intersection-controller.js";
+import { css, html } from "lit";
+import { property } from "lit/decorators.js";
+import { isArrowKeyPressed, getNextElementIndex } from "../../core/a11y.js";
+import { SbbElement } from "../../core/base-elements.js";
+import { SbbMediaQueryBreakpointUltraAndAbove, SbbMediaQueryBreakpointLargeAndAbove, SbbMediaQueryBreakpointSmallAndAbove, SbbMediaQueryBreakpointZeroAndAbove, SbbMediaMatcherController } from "../../core/controllers/media-matchers-controller.js";
+import { forceType } from "../../core/decorators.js";
+import { isLean } from "../../core/dom.js";
+import { boxSizingStyles } from "../../core/styles.js";
+const style = css`:host {
+  --sbb-stepper-orientation: row;
+  --sbb-stepper-border-width: var(--sbb-border-width-1x);
+  --sbb-stepper-marker-size: 0;
+  --sbb-stepper-marker-width: var(--sbb-border-width-3x);
+  --sbb-stepper-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-6x)
+  );
+  --sbb-stepper-marker-color: var(--sbb-color-3);
+  display: block;
+  position: relative;
+  counter-reset: step-label;
+}
+@media (forced-colors: active) {
+  :host {
+    --sbb-stepper-marker-color: ButtonText;
+  }
+}
+
+:host(:is(:state(disable-animation),[state--disable-animation])) {
+  --sbb-disable-animation-duration: 0s;
+}
+
+:host([orientation=vertical]) {
+  --sbb-stepper-orientation: column;
+}
+
+.sbb-stepper {
+  width: 100%;
+}
+
+.sbb-stepper__labels {
+  display: flex;
+  flex-direction: var(--sbb-stepper-orientation);
+  position: relative;
+  justify-content: start;
+  margin-block-end: var(--sbb-spacing-responsive-m);
+}
+.sbb-stepper__labels::before {
+  content: "";
+  position: absolute;
+  inset-inline-start: calc(var(--sbb-stepper-border-width) * -1);
+  background-color: var(--sbb-stepper-marker-color);
+}
+:host([orientation=horizontal]) .sbb-stepper__labels {
+  gap: var(--sbb-spacing-responsive-m);
+  padding-block-end: var(--sbb-spacing-fixed-4x);
+  border-block-end: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);
+}
+:host([orientation=horizontal]) .sbb-stepper__labels::before {
+  inset-block-end: calc(var(--sbb-stepper-border-width) * -1);
+  height: var(--sbb-stepper-marker-width);
+  width: var(--sbb-stepper-marker-size);
+  transition: width var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);
+}
+:host([orientation=vertical]) .sbb-stepper__labels {
+  padding-inline-start: var(--sbb-spacing-fixed-4x);
+  border-inline-start: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);
+}
+:host([orientation=vertical]) .sbb-stepper__labels::before {
+  inset-block-start: 0;
+  width: var(--sbb-stepper-marker-width);
+  height: var(--sbb-stepper-marker-size);
+  transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);
+}
+
+.sbb-stepper__steps {
+  position: relative;
+}
+:host([orientation=horizontal]) .sbb-stepper__steps {
+  height: var(--sbb-stepper-content-height);
+  transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);
+}
+
+::slotted(sbb-step-label)::before {
+  content: counter(step-label);
+  counter-increment: step-label;
+}`;
+const DEBOUNCE_TIME = 150;
+const breakpointMap = {
+  zero: SbbMediaQueryBreakpointZeroAndAbove,
+  small: SbbMediaQueryBreakpointSmallAndAbove,
+  large: SbbMediaQueryBreakpointLargeAndAbove,
+  ultra: SbbMediaQueryBreakpointUltraAndAbove
+};
+class SbbStepChangeEvent 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;
+  }
+}
+let SbbStepperElement = (() => {
+  var _linear_accessor_storage, _orientation_accessor_storage, _size_accessor_storage, _a;
+  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 _a = class extends _classSuper {
+    constructor() {
+      super();
+      __privateAdd(this, _linear_accessor_storage);
+      __privateAdd(this, _orientation_accessor_storage);
+      __privateAdd(this, _size_accessor_storage);
+      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();
+            }
+          });
+        }
+      }));
+      __privateSet(this, _linear_accessor_storage, __runInitializers(this, _linear_initializers, false));
+      this._horizontalFrom = (__runInitializers(this, _linear_extraInitializers), null);
+      __privateSet(this, _orientation_accessor_storage, __runInitializers(this, _orientation_initializers, "horizontal"));
+      __privateSet(this, _size_accessor_storage, (__runInitializers(this, _orientation_extraInitializers), __runInitializers(this, _size_initializers, isLean() ? "s" : "m")));
+      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));
+    }
+    /** If set to true, only the current and previous labels can be clicked and selected. */
+    get linear() {
+      return __privateGet(this, _linear_accessor_storage);
+    }
+    set linear(value) {
+      __privateSet(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;
+    }
+    /** Steps orientation, either horizontal or vertical. */
+    get orientation() {
+      return __privateGet(this, _orientation_accessor_storage);
+    }
+    set orientation(value) {
+      __privateSet(this, _orientation_accessor_storage, value);
+    }
+    /**
+     * Size variant, either s or m.
+     * @default 'm' / 's' (lean)
+     */
+    get size() {
+      return __privateGet(this, _size_accessor_storage);
+    }
+    set size(value) {
+      __privateSet(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;
+      });
+    }
+    /** 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;
+      }
+      const current = this.selected;
+      current?.deselect();
+      step.select();
+      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 || // don't trap nested handling
+      evt.target !== this && evt.target.parentElement !== this) {
+        return;
+      }
+      if (isArrowKeyPressed(evt)) {
+        const current = enabledSteps.indexOf(this.selected);
+        const nextIndex = getNextElementIndex(evt, current, enabledSteps.length);
+        this._select(enabledSteps[nextIndex]);
+        evt.preventDefault();
+      }
+    }
+    render() {
+      return html`
+      <div class="sbb-stepper">
+        <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>
+      </div>
+    `;
+    }
+  }, _linear_accessor_storage = new WeakMap(), _orientation_accessor_storage = new WeakMap(), _size_accessor_storage = new WeakMap(), (() => {
+    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(_a, 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(_a, 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(_a, 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(_a, 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(_a, 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(_a, 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(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.elementName = "sbb-stepper", _a.styles = [boxSizingStyles, style], _a.events = {
+    stepchange: "stepchange"
+  }, _a;
+})();
+export {
+  SbbStepChangeEvent,
+  SbbStepperElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"stepper.component.js","sources":["../../../../../src/elements/stepper/stepper/stepper.component.ts"],"sourcesContent":["import { IntersectionController } from '@lit-labs/observers/intersection-controller.js';\nimport { type CSSResultGroup, html, type PropertyValues, type TemplateResult } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { getNextElementIndex, isArrowKeyPressed } from '../../core/a11y.ts';\nimport { SbbElement } from '../../core/base-elements.ts';\nimport {\n  SbbMediaMatcherController,\n  SbbMediaQueryBreakpointLargeAndAbove,\n  SbbMediaQueryBreakpointSmallAndAbove,\n  SbbMediaQueryBreakpointUltraAndAbove,\n  SbbMediaQueryBreakpointZeroAndAbove,\n} from '../../core/controllers/media-matchers-controller.ts';\nimport { forceType } from '../../core/decorators.ts';\nimport { isLean } from '../../core/dom.ts';\nimport type { SbbHorizontalFrom, SbbOrientation } from '../../core/interfaces.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport type { SbbStepElement, SbbStepValidateEventDetails } from '../step/step.component.ts';\n\nimport style from './stepper.scss?lit&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 = [boxSizingStyles, 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: SbbOrientation = 'horizontal';\n\n  /**\n   * Size variant, either s or m.\n   * @default 'm' / 's' (lean)\n   */\n  @property({ reflect: true }) public accessor size: 's' | 'm' = isLean() ? 's' : 'm';\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\">\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      </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"],"names":[],"mappings":"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"}

package/development/stepper/stepper.js

@@ -1,10 +1,10 @@
-import { n as SbbStepperElement, t as SbbStepChangeEvent } from "../stepper.component-D1tAcpWs.js";
-//#region src/elements/stepper/stepper.ts
-/** @entrypoint */
+import { SbbStepperElement } from "./stepper/stepper.component.js";
+import { SbbStepChangeEvent } from "./stepper/stepper.component.js";
 SbbStepperElement.define();
 console.warn(`The entrypoint '@sbb-esta/elements/stepper/stepper.js' has been deprecated.
 Use either '@sbb-esta/elements/stepper.js' or '@sbb-esta/elements/stepper.pure.js' instead.`);
-//#endregion
-export { SbbStepChangeEvent, SbbStepperElement };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcHBlci5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvc3RlcHBlci9zdGVwcGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHsgU2JiU3RlcHBlckVsZW1lbnQgfSBmcm9tICcuL3N0ZXBwZXIvc3RlcHBlci5jb21wb25lbnQudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL3N0ZXBwZXIvc3RlcHBlci5jb21wb25lbnQudHMnO1xuXG5TYmJTdGVwcGVyRWxlbWVudC5kZWZpbmUoKTtcblxuY29uc29sZS53YXJuKGBUaGUgZW50cnlwb2ludCAnQHNiYi1lc3RhL2VsZW1lbnRzL3N0ZXBwZXIvc3RlcHBlci5qcycgaGFzIGJlZW4gZGVwcmVjYXRlZC5cblVzZSBlaXRoZXIgJ0BzYmItZXN0YS9lbGVtZW50cy9zdGVwcGVyLmpzJyBvciAnQHNiYi1lc3RhL2VsZW1lbnRzL3N0ZXBwZXIucHVyZS5qcycgaW5zdGVhZC5gKTtcbiJdLCJtYXBwaW5ncyI6Ijs7O0FBS0Esa0JBQWtCLFFBQVE7QUFFMUIsUUFBUSxLQUFLOzZGQUNnRiJ9
+export {
+  SbbStepChangeEvent,
+  SbbStepperElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcHBlci5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL3N0ZXBwZXIvc3RlcHBlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYlN0ZXBwZXJFbGVtZW50IH0gZnJvbSAnLi9zdGVwcGVyL3N0ZXBwZXIuY29tcG9uZW50LnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9zdGVwcGVyL3N0ZXBwZXIuY29tcG9uZW50LnRzJztcblxuU2JiU3RlcHBlckVsZW1lbnQuZGVmaW5lKCk7XG5cbmNvbnNvbGUud2FybihgVGhlIGVudHJ5cG9pbnQgJ0BzYmItZXN0YS9lbGVtZW50cy9zdGVwcGVyL3N0ZXBwZXIuanMnIGhhcyBiZWVuIGRlcHJlY2F0ZWQuXG5Vc2UgZWl0aGVyICdAc2JiLWVzdGEvZWxlbWVudHMvc3RlcHBlci5qcycgb3IgJ0BzYmItZXN0YS9lbGVtZW50cy9zdGVwcGVyLnB1cmUuanMnIGluc3RlYWQuYCk7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFLQSxrQkFBa0IsT0FBQTtBQUVsQixRQUFRLEtBQUs7QUFBQSw0RkFDK0U7In0=

package/development/stepper.js

@@ -1,13 +1,14 @@
-import { t as SbbStepLabelElement } from "./step-label.component-BH28AI5Z.js";
-import { t as SbbStepElement } from "./step.component-WY7qdrR8.js";
-import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-D1tAcpWs.js";
-import "./stepper.pure.js";
-//#region src/elements/stepper.ts
-/** @entrypoint */
+import { SbbStepLabelElement } from "./stepper/step-label/step-label.component.js";
+import { SbbStepElement } from "./stepper/step/step.component.js";
+import { SbbStepperElement } from "./stepper/stepper/stepper.component.js";
+import { SbbStepChangeEvent } from "./stepper/stepper/stepper.component.js";
 SbbStepElement.define();
 SbbStepLabelElement.define();
 SbbStepperElement.define();
-//#endregion
-export { SbbStepChangeEvent, SbbStepElement, SbbStepLabelElement, SbbStepperElement };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcHBlci5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvc3RlcHBlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYlN0ZXBFbGVtZW50LCBTYmJTdGVwTGFiZWxFbGVtZW50LCBTYmJTdGVwcGVyRWxlbWVudCB9IGZyb20gJy4vc3RlcHBlci5wdXJlLnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9zdGVwcGVyLnB1cmUudHMnO1xuXG5TYmJTdGVwRWxlbWVudC5kZWZpbmUoKTtcblNiYlN0ZXBMYWJlbEVsZW1lbnQuZGVmaW5lKCk7XG5TYmJTdGVwcGVyRWxlbWVudC5kZWZpbmUoKTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBS0EsZUFBZSxRQUFRO0FBQ3ZCLG9CQUFvQixRQUFRO0FBQzVCLGtCQUFrQixRQUFRIn0=
+export {
+  SbbStepChangeEvent,
+  SbbStepElement,
+  SbbStepLabelElement,
+  SbbStepperElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcHBlci5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VsZW1lbnRzL3N0ZXBwZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5pbXBvcnQgeyBTYmJTdGVwRWxlbWVudCwgU2JiU3RlcExhYmVsRWxlbWVudCwgU2JiU3RlcHBlckVsZW1lbnQgfSBmcm9tICcuL3N0ZXBwZXIucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vc3RlcHBlci5wdXJlLnRzJztcblxuU2JiU3RlcEVsZW1lbnQuZGVmaW5lKCk7XG5TYmJTdGVwTGFiZWxFbGVtZW50LmRlZmluZSgpO1xuU2JiU3RlcHBlckVsZW1lbnQuZGVmaW5lKCk7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUtBLGVBQWUsT0FBQTtBQUNmLG9CQUFvQixPQUFBO0FBQ3BCLGtCQUFrQixPQUFBOyJ9

package/development/stepper.pure.js

@@ -1,4 +1,10 @@
-import { t as SbbStepLabelElement } from "./step-label.component-BH28AI5Z.js";
-import { t as SbbStepElement } from "./step.component-WY7qdrR8.js";
-import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-D1tAcpWs.js";
-export { SbbStepChangeEvent, SbbStepElement, SbbStepLabelElement, SbbStepperElement };
+import { SbbStepLabelElement } from "./stepper/step-label/step-label.component.js";
+import { SbbStepElement } from "./stepper/step/step.component.js";
+import { SbbStepChangeEvent, SbbStepperElement } from "./stepper/stepper/stepper.component.js";
+export {
+  SbbStepChangeEvent,
+  SbbStepElement,
+  SbbStepLabelElement,
+  SbbStepperElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcHBlci5wdXJlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OyJ9