@sbb-esta/lyne-elements-dev 4.7.0-dev.1773149675 → 4.7.0-dev.1773157346

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

@@ -1,9 +1,8 @@
-import { __esDecorate, __runInitializers } from "tslib";
 import { ResizeController } from "@lit-labs/observers/resize-controller.js";
-import { css, LitElement, html } from "lit";
-import { customElement } from "lit/decorators.js";
+import { css, html } from "lit";
+import { SbbElement } from "../../core/base-elements.js";
 import { SbbPropertyWatcherController } from "../../core/controllers.js";
-import { SbbElementInternalsMixin, removeAriaElements, appendAriaElements } from "../../core/mixins.js";
+import { removeAriaElements, appendAriaElements } from "../../core/mixins.js";
 import { boxSizingStyles } from "../../core/styles.js";
 const style = css`:host {
   --sbb-step-position: initial;
@@ -74,153 +73,144 @@ const style = css`:host {
   }
 }`;
 let nextId = 0;
-let SbbStepElement = (() => {
-  var _a;
-  let _classDecorators = [customElement("sbb-step")];
-  let _classDescriptor;
-  let _classExtraInitializers = [];
-  let _classThis;
-  let _classSuper = SbbElementInternalsMixin(LitElement);
-  _a = class extends _classSuper {
-    /** The label of the step. */
-    get label() {
-      return this._label;
-    }
-    get stepper() {
-      return this.closest("sbb-stepper");
-    }
-    constructor() {
-      super();
-      this._stepResizeObserver = new ResizeController(this, {
-        target: null,
-        skipInitial: true,
-        callback: () => setTimeout(() => this._onStepElementResize())
-      });
-      this._label = null;
-      this.addEventListener?.("click", (e) => this._handleClick(e));
-      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}`);
-          }
+const _SbbStepElement = class _SbbStepElement extends SbbElement {
+  /** The label of the step. */
+  get label() {
+    return this._label;
+  }
+  get stepper() {
+    return this.closest("sbb-stepper");
+  }
+  constructor() {
+    super();
+    this._stepResizeObserver = new ResizeController(this, {
+      target: null,
+      skipInitial: true,
+      callback: () => setTimeout(() => this._onStepElementResize())
+    });
+    this._label = null;
+    this.addEventListener?.("click", (e) => this._handleClick(e));
+    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}`);
         }
-      }));
-    }
-    /**
-     * Selects and configures the step.
-     * @internal
-     * TODO: @breaking-change: make protected
-     */
-    select() {
-      if (!this.hasUpdated || !this.label) {
-        return;
-      }
-      this.internals.states.add("selected");
-      this.label.select();
-    }
-    /**
-     * Deselects and configures the step.
-     * @internal
-     * TODO: @breaking-change: make protected
-     */
-    deselect() {
-      if (!this.label) {
-        return;
-      }
-      this.internals.states.delete("selected");
-      this.label.deselect();
-    }
-    /**
-     * Emits a validate event whenever step switch is triggered.
-     * @internal
-     * TODO: @breaking-change: make protected
-     */
-    validate(eventData) {
-      return this.dispatchEvent(new CustomEvent("validate", {
-        bubbles: true,
-        composed: true,
-        cancelable: true,
-        detail: eventData
-      }));
-    }
-    /**
-     * Configures the step.
-     * @internal
-     * TODO: @breaking-change: make protected
-     */
-    configure(stepperLoaded) {
-      if (stepperLoaded) {
-        this._assignLabel();
-      }
-    }
-    /** Watches for clicked elements with `sbb-stepper-next` or `sbb-stepper-previous` attributes. */
-    _handleClick(event) {
-      const composedPathElements = event.composedPath().filter((el) => el instanceof window.HTMLElement);
-      if (composedPathElements.some((el) => this._isGoNextElement(el))) {
-        this.stepper?.next();
-      } else if (composedPathElements.some((el) => this._isGoPreviousElement(el))) {
-        this.stepper?.previous();
       }
+    }));
+  }
+  /**
+   * Selects and configures the step.
+   * @internal
+   * TODO: @breaking-change: make protected
+   */
+  select() {
+    if (!this.hasUpdated || !this.label) {
+      return;
     }
-    _isGoNextElement(element) {
-      return element.hasAttribute("sbb-stepper-next") && !element.hasAttribute("disabled");
-    }
-    _isGoPreviousElement(element) {
-      return element.hasAttribute("sbb-stepper-previous") && !element.hasAttribute("disabled");
-    }
-    _onStepElementResize() {
-      if (!this.matches(":is(:state(selected),[state--selected])")) {
-        return;
-      }
-      this.dispatchEvent(new Event("resizechange", { bubbles: true }));
+    this.internals.states.add("selected");
+    this.label.select();
+  }
+  /**
+   * Deselects and configures the step.
+   * @internal
+   * TODO: @breaking-change: make protected
+   */
+  deselect() {
+    if (!this.label) {
+      return;
     }
-    connectedCallback() {
-      super.connectedCallback();
-      this.id ||= `sbb-step-${nextId++}`;
-      this.slot ||= "step";
+    this.internals.states.delete("selected");
+    this.label.deselect();
+  }
+  /**
+   * Emits a validate event whenever step switch is triggered.
+   * @internal
+   * TODO: @breaking-change: make protected
+   */
+  validate(eventData) {
+    return this.dispatchEvent(new CustomEvent("validate", {
+      bubbles: true,
+      composed: true,
+      cancelable: true,
+      detail: eventData
+    }));
+  }
+  /**
+   * Configures the step.
+   * @internal
+   * TODO: @breaking-change: make protected
+   */
+  configure(stepperLoaded) {
+    if (stepperLoaded) {
       this._assignLabel();
     }
-    firstUpdated(changedProperties) {
-      super.firstUpdated(changedProperties);
-      this.updateComplete.then(() => {
-        this._stepResizeObserver.observe(this.shadowRoot.querySelector(".sbb-step"));
-      });
+  }
+  /** Watches for clicked elements with `sbb-stepper-next` or `sbb-stepper-previous` attributes. */
+  _handleClick(event) {
+    const composedPathElements = event.composedPath().filter((el) => el instanceof window.HTMLElement);
+    if (composedPathElements.some((el) => this._isGoNextElement(el))) {
+      this.stepper?.next();
+    } else if (composedPathElements.some((el) => this._isGoPreviousElement(el))) {
+      this.stepper?.previous();
     }
-    _assignLabel() {
-      let previousSibling = this.previousElementSibling;
-      while (previousSibling && previousSibling.localName !== "sbb-step-label") {
-        previousSibling = previousSibling.previousElementSibling;
-      }
-      const value = previousSibling;
-      this.internals.ariaLabelledByElements = removeAriaElements(this.internals.ariaLabelledByElements, this._label);
-      this._label = value instanceof Element ? value : null;
-      this.internals.ariaLabelledByElements = appendAriaElements(this.internals.ariaLabelledByElements, this._label);
+  }
+  _isGoNextElement(element) {
+    return element.hasAttribute("sbb-stepper-next") && !element.hasAttribute("disabled");
+  }
+  _isGoPreviousElement(element) {
+    return element.hasAttribute("sbb-stepper-previous") && !element.hasAttribute("disabled");
+  }
+  _onStepElementResize() {
+    if (!this.matches(":is(:state(selected),[state--selected])")) {
+      return;
     }
-    render() {
-      return html`
+    this.dispatchEvent(new Event("resizechange", { bubbles: true }));
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.id ||= `sbb-step-${nextId++}`;
+    this.slot ||= "step";
+    this._assignLabel();
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    this.updateComplete.then(() => {
+      this._stepResizeObserver.observe(this.shadowRoot.querySelector(".sbb-step"));
+    });
+  }
+  _assignLabel() {
+    let previousSibling = this.previousElementSibling;
+    while (previousSibling && previousSibling.localName !== "sbb-step-label") {
+      previousSibling = previousSibling.previousElementSibling;
+    }
+    const value = previousSibling;
+    this.internals.ariaLabelledByElements = removeAriaElements(this.internals.ariaLabelledByElements, this._label);
+    this._label = value instanceof Element ? value : null;
+    this.internals.ariaLabelledByElements = appendAriaElements(this.internals.ariaLabelledByElements, this._label);
+  }
+  render() {
+    return html`
       <div class="sbb-step--wrapper">
         <div class="sbb-step">
           <slot></slot>
         </div>
       </div>
     `;
-    }
-  }, _classThis = _a, (() => {
-    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-    _classThis = _classDescriptor.value;
-    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-  })(), _a.role = "tabpanel", _a.styles = [boxSizingStyles, style], _a.events = {
-    validate: "validate",
-    resizechange: "resizechange"
-  }, __runInitializers(_classThis, _classExtraInitializers), _a;
-  return _classThis;
-})();
+  }
+};
+_SbbStepElement.elementName = "sbb-step";
+_SbbStepElement.role = "tabpanel";
+_SbbStepElement.styles = [boxSizingStyles, style];
+_SbbStepElement.events = {
+  validate: "validate",
+  resizechange: "resizechange"
+};
+let SbbStepElement = _SbbStepElement;
 export {
   SbbStepElement
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"step.component.js","sources":["../../../../../src/elements/stepper/step/step.component.ts"],"sourcesContent":["import { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  LitElement,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement } from 'lit/decorators.js';\n\nimport { SbbPropertyWatcherController } from '../../core/controllers.ts';\nimport {\n  appendAriaElements,\n  removeAriaElements,\n  SbbElementInternalsMixin,\n} from '../../core/mixins.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport type { SbbStepLabelElement } from '../step-label.ts';\nimport type { SbbStepperElement } from '../stepper.ts';\n\nimport style from './step.scss?lit&inline';\n\nlet nextId = 0;\n\nexport type SbbStepValidateEventDetails = {\n  currentIndex: number | null;\n  currentStep: SbbStepElement | null;\n  nextIndex: number | null;\n  nextStep: SbbStepElement | null;\n};\n\n/**\n * Combined with a `sbb-stepper`, it displays a step's content.\n *\n * @slot - Use the unnamed slot to provide content.\n */\nexport\n@customElement('sbb-step')\nclass SbbStepElement extends SbbElementInternalsMixin(LitElement) {\n  public static override readonly role = 'tabpanel';\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n  public static readonly events = {\n    validate: 'validate',\n    resizechange: 'resizechange',\n  } as const;\n\n  // We use a timeout as a workaround to the \"ResizeObserver loop completed with undelivered notifications\" error.\n  // For more details:\n  // - https://github.com/WICG/resize-observer/issues/38#issuecomment-422126006\n  // - https://github.com/juggle/resize-observer/issues/103#issuecomment-1711148285\n  private _stepResizeObserver = new ResizeController(this, {\n    target: null,\n    skipInitial: true,\n    callback: () => setTimeout(() => this._onStepElementResize()),\n  });\n\n  /** The label of the step. */\n  public get label(): SbbStepLabelElement | null {\n    return this._label;\n  }\n  private _label: SbbStepLabelElement | null = null;\n\n  public get stepper(): SbbStepperElement | null {\n    return this.closest('sbb-stepper');\n  }\n\n  private _previousOrientation?: string;\n\n  public constructor() {\n    super();\n    this.addEventListener?.('click', (e) => this._handleClick(e));\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      }),\n    );\n  }\n\n  /**\n   * Selects and configures the step.\n   * @internal\n   * TODO: @breaking-change: make protected\n   */\n  public select(): void {\n    if (!this.hasUpdated || !this.label) {\n      return;\n    }\n    this.internals.states.add('selected');\n    this.label.select();\n  }\n\n  /**\n   * Deselects and configures the step.\n   * @internal\n   * TODO: @breaking-change: make protected\n   */\n  public deselect(): void {\n    if (!this.label) {\n      return;\n    }\n    this.internals.states.delete('selected');\n    this.label.deselect();\n  }\n\n  /**\n   * Emits a validate event whenever step switch is triggered.\n   * @internal\n   * TODO: @breaking-change: make protected\n   */\n  public validate(eventData: SbbStepValidateEventDetails): boolean {\n    // TODO: @breaking-change: Create a specific event type for this event.\n    /**\n     * @type {CustomEvent<SbbStepValidateEventDetails>}\n     * The validate event is dispatched when a step change is triggered. Can be canceled to abort the step change.\n     */\n    return this.dispatchEvent(\n      new CustomEvent<SbbStepValidateEventDetails>('validate', {\n        bubbles: true,\n        composed: true,\n        cancelable: true,\n        detail: eventData,\n      }),\n    );\n  }\n\n  /**\n   * Configures the step.\n   * @internal\n   * TODO: @breaking-change: make protected\n   */\n  public configure(stepperLoaded: boolean): void {\n    if (stepperLoaded) {\n      this._assignLabel();\n    }\n  }\n\n  /** Watches for clicked elements with `sbb-stepper-next` or `sbb-stepper-previous` attributes. */\n  private _handleClick(event: Event): void {\n    const composedPathElements = event\n      .composedPath()\n      .filter((el) => el instanceof window.HTMLElement);\n    if (composedPathElements.some((el) => this._isGoNextElement(el as HTMLElement))) {\n      this.stepper?.next();\n    } else if (composedPathElements.some((el) => this._isGoPreviousElement(el as HTMLElement))) {\n      this.stepper?.previous();\n    }\n  }\n\n  private _isGoNextElement(element: HTMLElement): boolean {\n    return element.hasAttribute('sbb-stepper-next') && !element.hasAttribute('disabled');\n  }\n\n  private _isGoPreviousElement(element: HTMLElement): boolean {\n    return element.hasAttribute('sbb-stepper-previous') && !element.hasAttribute('disabled');\n  }\n\n  private _onStepElementResize(): void {\n    if (!this.matches(':state(selected)')) {\n      return;\n    }\n\n    /**\n     * @internal\n     * Emits when a resize happens, used to avoid setting the height of the stepper from the step component.\n     */\n    this.dispatchEvent(new Event('resizechange', { bubbles: true }));\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.id ||= `sbb-step-${nextId++}`;\n    this.slot ||= 'step';\n    this._assignLabel();\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this.updateComplete.then(() => {\n      this._stepResizeObserver.observe(this.shadowRoot!.querySelector('.sbb-step') as HTMLElement);\n    });\n  }\n\n  private _assignLabel(): void {\n    let previousSibling = this.previousElementSibling;\n    while (previousSibling && previousSibling.localName !== 'sbb-step-label') {\n      previousSibling = previousSibling.previousElementSibling;\n    }\n    const value = previousSibling as SbbStepLabelElement | null;\n\n    this.internals.ariaLabelledByElements = removeAriaElements(\n      this.internals.ariaLabelledByElements,\n      this._label,\n    );\n    this._label = value instanceof Element ? value : null;\n    this.internals.ariaLabelledByElements = appendAriaElements(\n      this.internals.ariaLabelledByElements,\n      this._label,\n    );\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-step--wrapper\">\n        <div class=\"sbb-step\">\n          <slot></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-step': SbbStepElement;\n  }\n}\n\ndeclare global {\n  interface GlobalEventHandlersEventMap {\n    resizechange: Event;\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,IAAI,SAAS;IAgBP,kBAAc,MAAA;;0BADnB,cAAc,UAAU,CAAC;;;;oBACG,yBAAyB,UAAU;AAA3C,EAAA,mBAAQ,YAAoC;AAAA;AAAA,IAmB/D,IAAW,QAAK;AACd,aAAO,KAAK;AAAA,IACd;AAAA,IAGA,IAAW,UAAO;AAChB,aAAO,KAAK,QAAQ,aAAa;AAAA,IACnC;AAAA,IAIA,cAAA;AACE,YAAA;AAnBM,WAAA,sBAAsB,IAAI,iBAAiB,MAAM;AAAA,QACvD,QAAQ;AAAA,QACR,aAAa;AAAA,QACb,UAAU,MAAM,WAAW,MAAM,KAAK,sBAAsB;AAAA,MAAA,CAC7D;AAMO,WAAA,SAAqC;AAU3C,WAAK,mBAAmB,SAAS,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC;AAC5D,WAAK,cACH,IAAI,6BAA6B,MAAM,MAAM,KAAK,SAAS;AAAA,QACzD,aAAa,CAAC,MAAK;AACjB,cAAI,KAAK,sBAAsB;AAC7B,iBAAK,UAAU,OAAO,OAAO,eAAe,KAAK,oBAAoB,EAAE;AAAA,UACzE;AACA,eAAK,uBAAuB,EAAE;AAC9B,cAAI,KAAK,sBAAsB;AAC7B,iBAAK,UAAU,OAAO,IAAI,eAAe,KAAK,oBAAoB,EAAE;AAAA,UACtE;AAAA,QACF;AAAA,MAAA,CACD,CAAC;AAAA,IAEN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOO,SAAM;AACX,UAAI,CAAC,KAAK,cAAc,CAAC,KAAK,OAAO;AACnC;AAAA,MACF;AACA,WAAK,UAAU,OAAO,IAAI,UAAU;AACpC,WAAK,MAAM,OAAA;AAAA,IACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOO,WAAQ;AACb,UAAI,CAAC,KAAK,OAAO;AACf;AAAA,MACF;AACA,WAAK,UAAU,OAAO,OAAO,UAAU;AACvC,WAAK,MAAM,SAAA;AAAA,IACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOO,SAAS,WAAsC;AAMpD,aAAO,KAAK,cACV,IAAI,YAAyC,YAAY;AAAA,QACvD,SAAS;AAAA,QACT,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,QAAQ;AAAA,MAAA,CACT,CAAC;AAAA,IAEN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOO,UAAU,eAAsB;AACrC,UAAI,eAAe;AACjB,aAAK,aAAA;AAAA,MACP;AAAA,IACF;AAAA;AAAA,IAGQ,aAAa,OAAY;AAC/B,YAAM,uBAAuB,MAC1B,eACA,OAAO,CAAC,OAAO,cAAc,OAAO,WAAW;AAClD,UAAI,qBAAqB,KAAK,CAAC,OAAO,KAAK,iBAAiB,EAAiB,CAAC,GAAG;AAC/E,aAAK,SAAS,KAAA;AAAA,MAChB,WAAW,qBAAqB,KAAK,CAAC,OAAO,KAAK,qBAAqB,EAAiB,CAAC,GAAG;AAC1F,aAAK,SAAS,SAAA;AAAA,MAChB;AAAA,IACF;AAAA,IAEQ,iBAAiB,SAAoB;AAC3C,aAAO,QAAQ,aAAa,kBAAkB,KAAK,CAAC,QAAQ,aAAa,UAAU;AAAA,IACrF;AAAA,IAEQ,qBAAqB,SAAoB;AAC/C,aAAO,QAAQ,aAAa,sBAAsB,KAAK,CAAC,QAAQ,aAAa,UAAU;AAAA,IACzF;AAAA,IAEQ,uBAAoB;AAC1B,UAAI,CAAC,KAAK,QAAQ,yCAAkB,GAAG;AACrC;AAAA,MACF;AAMA,WAAK,cAAc,IAAI,MAAM,gBAAgB,EAAE,SAAS,KAAA,CAAM,CAAC;AAAA,IACjE;AAAA,IAEgB,oBAAiB;AAC/B,YAAM,kBAAA;AACN,WAAK,OAAO,YAAY,QAAQ;AAChC,WAAK,SAAS;AACd,WAAK,aAAA;AAAA,IACP;AAAA,IAEmB,aAAa,mBAAuC;AACrE,YAAM,aAAa,iBAAiB;AACpC,WAAK,eAAe,KAAK,MAAK;AAC5B,aAAK,oBAAoB,QAAQ,KAAK,WAAY,cAAc,WAAW,CAAgB;AAAA,MAC7F,CAAC;AAAA,IACH;AAAA,IAEQ,eAAY;AAClB,UAAI,kBAAkB,KAAK;AAC3B,aAAO,mBAAmB,gBAAgB,cAAc,kBAAkB;AACxE,0BAAkB,gBAAgB;AAAA,MACpC;AACA,YAAM,QAAQ;AAEd,WAAK,UAAU,yBAAyB,mBACtC,KAAK,UAAU,wBACf,KAAK,MAAM;AAEb,WAAK,SAAS,iBAAiB,UAAU,QAAQ;AACjD,WAAK,UAAU,yBAAyB,mBACtC,KAAK,UAAU,wBACf,KAAK,MAAM;AAAA,IAEf;AAAA,IAEmB,SAAM;AACvB,aAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOT;AAAA;;AAlLF,iBAAA,MAAA,mBAAA,EAAA,OAAA,WAAA,GAAA,kBAAA,EAAA,MAAA,SAAA,MAAA,WAAA,MAAA,UAAA,UAAA,GAAA,MAAA,uBAAA;;;QACkC,GAAA,OAAO,YAChB,GAAA,SAAyB,CAAC,iBAAiB,KAAK,GAChD,GAAA,SAAS;AAAA,IAC9B,UAAU;AAAA,IACV,cAAc;AAAA,EAAA,GALZ,kBAAA,YAAA,uBAAA,GAAe;;;"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"step.component.js","sources":["../../../../../src/elements/stepper/step/step.component.ts"],"sourcesContent":["import { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport { type CSSResultGroup, html, type PropertyValues, type TemplateResult } from 'lit';\n\nimport { SbbElement } from '../../core/base-elements.ts';\nimport { SbbPropertyWatcherController } from '../../core/controllers.ts';\nimport { appendAriaElements, removeAriaElements } from '../../core/mixins.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport type { SbbStepLabelElement } from '../step-label/step-label.component.ts';\nimport type { SbbStepperElement } from '../stepper/stepper.component.ts';\n\nimport style from './step.scss?lit&inline';\n\nlet nextId = 0;\n\nexport interface SbbStepValidateEventDetails {\n  currentIndex: number | null;\n  currentStep: SbbStepElement | null;\n  nextIndex: number | null;\n  nextStep: SbbStepElement | null;\n}\n\n/**\n * Combined with a `sbb-stepper`, it displays a step's content.\n *\n * @slot - Use the unnamed slot to provide content.\n */\nexport class SbbStepElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-step';\n  public static override readonly role = 'tabpanel';\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n  public static readonly events = {\n    validate: 'validate',\n    resizechange: 'resizechange',\n  } as const;\n\n  // We use a timeout as a workaround to the \"ResizeObserver loop completed with undelivered notifications\" error.\n  // For more details:\n  // - https://github.com/WICG/resize-observer/issues/38#issuecomment-422126006\n  // - https://github.com/juggle/resize-observer/issues/103#issuecomment-1711148285\n  private _stepResizeObserver = new ResizeController(this, {\n    target: null,\n    skipInitial: true,\n    callback: () => setTimeout(() => this._onStepElementResize()),\n  });\n\n  /** The label of the step. */\n  public get label(): SbbStepLabelElement | null {\n    return this._label;\n  }\n  private _label: SbbStepLabelElement | null = null;\n\n  public get stepper(): SbbStepperElement | null {\n    return this.closest('sbb-stepper');\n  }\n\n  private _previousOrientation?: string;\n\n  public constructor() {\n    super();\n    this.addEventListener?.('click', (e) => this._handleClick(e));\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      }),\n    );\n  }\n\n  /**\n   * Selects and configures the step.\n   * @internal\n   * TODO: @breaking-change: make protected\n   */\n  public select(): void {\n    if (!this.hasUpdated || !this.label) {\n      return;\n    }\n    this.internals.states.add('selected');\n    this.label.select();\n  }\n\n  /**\n   * Deselects and configures the step.\n   * @internal\n   * TODO: @breaking-change: make protected\n   */\n  public deselect(): void {\n    if (!this.label) {\n      return;\n    }\n    this.internals.states.delete('selected');\n    this.label.deselect();\n  }\n\n  /**\n   * Emits a validate event whenever step switch is triggered.\n   * @internal\n   * TODO: @breaking-change: make protected\n   */\n  public validate(eventData: SbbStepValidateEventDetails): boolean {\n    // TODO: @breaking-change: Create a specific event type for this event.\n    /**\n     * @type {CustomEvent<SbbStepValidateEventDetails>}\n     * The validate event is dispatched when a step change is triggered. Can be canceled to abort the step change.\n     */\n    return this.dispatchEvent(\n      new CustomEvent<SbbStepValidateEventDetails>('validate', {\n        bubbles: true,\n        composed: true,\n        cancelable: true,\n        detail: eventData,\n      }),\n    );\n  }\n\n  /**\n   * Configures the step.\n   * @internal\n   * TODO: @breaking-change: make protected\n   */\n  public configure(stepperLoaded: boolean): void {\n    if (stepperLoaded) {\n      this._assignLabel();\n    }\n  }\n\n  /** Watches for clicked elements with `sbb-stepper-next` or `sbb-stepper-previous` attributes. */\n  private _handleClick(event: Event): void {\n    const composedPathElements = event\n      .composedPath()\n      .filter((el) => el instanceof window.HTMLElement);\n    if (composedPathElements.some((el) => this._isGoNextElement(el as HTMLElement))) {\n      this.stepper?.next();\n    } else if (composedPathElements.some((el) => this._isGoPreviousElement(el as HTMLElement))) {\n      this.stepper?.previous();\n    }\n  }\n\n  private _isGoNextElement(element: HTMLElement): boolean {\n    return element.hasAttribute('sbb-stepper-next') && !element.hasAttribute('disabled');\n  }\n\n  private _isGoPreviousElement(element: HTMLElement): boolean {\n    return element.hasAttribute('sbb-stepper-previous') && !element.hasAttribute('disabled');\n  }\n\n  private _onStepElementResize(): void {\n    if (!this.matches(':state(selected)')) {\n      return;\n    }\n\n    /**\n     * @internal\n     * Emits when a resize happens, used to avoid setting the height of the stepper from the step component.\n     */\n    this.dispatchEvent(new Event('resizechange', { bubbles: true }));\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.id ||= `sbb-step-${nextId++}`;\n    this.slot ||= 'step';\n    this._assignLabel();\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this.updateComplete.then(() => {\n      this._stepResizeObserver.observe(this.shadowRoot!.querySelector('.sbb-step') as HTMLElement);\n    });\n  }\n\n  private _assignLabel(): void {\n    let previousSibling = this.previousElementSibling;\n    while (previousSibling && previousSibling.localName !== 'sbb-step-label') {\n      previousSibling = previousSibling.previousElementSibling;\n    }\n    const value = previousSibling as SbbStepLabelElement | null;\n\n    this.internals.ariaLabelledByElements = removeAriaElements(\n      this.internals.ariaLabelledByElements,\n      this._label,\n    );\n    this._label = value instanceof Element ? value : null;\n    this.internals.ariaLabelledByElements = appendAriaElements(\n      this.internals.ariaLabelledByElements,\n      this._label,\n    );\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-step--wrapper\">\n        <div class=\"sbb-step\">\n          <slot></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-step': SbbStepElement;\n  }\n}\n\ndeclare global {\n  interface GlobalEventHandlersEventMap {\n    resizechange: Event;\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,IAAI,SAAS;AAcP,MAAO,kBAAP,MAAO,wBAAuB,WAAU;AAAA;AAAA,EAoB5C,IAAW,QAAK;AACd,WAAO,KAAK;AAAA,EACd;AAAA,EAGA,IAAW,UAAO;AAChB,WAAO,KAAK,QAAQ,aAAa;AAAA,EACnC;AAAA,EAIA,cAAA;AACE,UAAA;AAnBM,SAAA,sBAAsB,IAAI,iBAAiB,MAAM;AAAA,MACvD,QAAQ;AAAA,MACR,aAAa;AAAA,MACb,UAAU,MAAM,WAAW,MAAM,KAAK,sBAAsB;AAAA,IAAA,CAC7D;AAMO,SAAA,SAAqC;AAU3C,SAAK,mBAAmB,SAAS,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC;AAC5D,SAAK,cACH,IAAI,6BAA6B,MAAM,MAAM,KAAK,SAAS;AAAA,MACzD,aAAa,CAAC,MAAK;AACjB,YAAI,KAAK,sBAAsB;AAC7B,eAAK,UAAU,OAAO,OAAO,eAAe,KAAK,oBAAoB,EAAE;AAAA,QACzE;AACA,aAAK,uBAAuB,EAAE;AAC9B,YAAI,KAAK,sBAAsB;AAC7B,eAAK,UAAU,OAAO,IAAI,eAAe,KAAK,oBAAoB,EAAE;AAAA,QACtE;AAAA,MACF;AAAA,IAAA,CACD,CAAC;AAAA,EAEN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,SAAM;AACX,QAAI,CAAC,KAAK,cAAc,CAAC,KAAK,OAAO;AACnC;AAAA,IACF;AACA,SAAK,UAAU,OAAO,IAAI,UAAU;AACpC,SAAK,MAAM,OAAA;AAAA,EACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,WAAQ;AACb,QAAI,CAAC,KAAK,OAAO;AACf;AAAA,IACF;AACA,SAAK,UAAU,OAAO,OAAO,UAAU;AACvC,SAAK,MAAM,SAAA;AAAA,EACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,SAAS,WAAsC;AAMpD,WAAO,KAAK,cACV,IAAI,YAAyC,YAAY;AAAA,MACvD,SAAS;AAAA,MACT,UAAU;AAAA,MACV,YAAY;AAAA,MACZ,QAAQ;AAAA,IAAA,CACT,CAAC;AAAA,EAEN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,UAAU,eAAsB;AACrC,QAAI,eAAe;AACjB,WAAK,aAAA;AAAA,IACP;AAAA,EACF;AAAA;AAAA,EAGQ,aAAa,OAAY;AAC/B,UAAM,uBAAuB,MAC1B,eACA,OAAO,CAAC,OAAO,cAAc,OAAO,WAAW;AAClD,QAAI,qBAAqB,KAAK,CAAC,OAAO,KAAK,iBAAiB,EAAiB,CAAC,GAAG;AAC/E,WAAK,SAAS,KAAA;AAAA,IAChB,WAAW,qBAAqB,KAAK,CAAC,OAAO,KAAK,qBAAqB,EAAiB,CAAC,GAAG;AAC1F,WAAK,SAAS,SAAA;AAAA,IAChB;AAAA,EACF;AAAA,EAEQ,iBAAiB,SAAoB;AAC3C,WAAO,QAAQ,aAAa,kBAAkB,KAAK,CAAC,QAAQ,aAAa,UAAU;AAAA,EACrF;AAAA,EAEQ,qBAAqB,SAAoB;AAC/C,WAAO,QAAQ,aAAa,sBAAsB,KAAK,CAAC,QAAQ,aAAa,UAAU;AAAA,EACzF;AAAA,EAEQ,uBAAoB;AAC1B,QAAI,CAAC,KAAK,QAAQ,yCAAkB,GAAG;AACrC;AAAA,IACF;AAMA,SAAK,cAAc,IAAI,MAAM,gBAAgB,EAAE,SAAS,KAAA,CAAM,CAAC;AAAA,EACjE;AAAA,EAEgB,oBAAiB;AAC/B,UAAM,kBAAA;AACN,SAAK,OAAO,YAAY,QAAQ;AAChC,SAAK,SAAS;AACd,SAAK,aAAA;AAAA,EACP;AAAA,EAEmB,aAAa,mBAAuC;AACrE,UAAM,aAAa,iBAAiB;AACpC,SAAK,eAAe,KAAK,MAAK;AAC5B,WAAK,oBAAoB,QAAQ,KAAK,WAAY,cAAc,WAAW,CAAgB;AAAA,IAC7F,CAAC;AAAA,EACH;AAAA,EAEQ,eAAY;AAClB,QAAI,kBAAkB,KAAK;AAC3B,WAAO,mBAAmB,gBAAgB,cAAc,kBAAkB;AACxE,wBAAkB,gBAAgB;AAAA,IACpC;AACA,UAAM,QAAQ;AAEd,SAAK,UAAU,yBAAyB,mBACtC,KAAK,UAAU,wBACf,KAAK,MAAM;AAEb,SAAK,SAAS,iBAAiB,UAAU,QAAQ;AACjD,SAAK,UAAU,yBAAyB,mBACtC,KAAK,UAAU,wBACf,KAAK,MAAM;AAAA,EAEf;AAAA,EAEmB,SAAM;AACvB,WAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOT;;AAlLgC,gBAAA,cAAsB;AACtB,gBAAA,OAAO;AAChB,gBAAA,SAAyB,CAAC,iBAAiB,KAAK;AAChD,gBAAA,SAAS;AAAA,EAC9B,UAAU;AAAA,EACV,cAAc;AAAA;AANZ,IAAO,iBAAP;"}

package/development/stepper/step-label/step-label.component.d.ts

@@ -1,7 +1,7 @@
 import { CSSResultGroup, TemplateResult } from 'lit';
 import { SbbButtonBaseElement } from '../../core/base-elements.ts';
-import { SbbStepElement } from '../step.ts';
-import { SbbStepperElement } from '../stepper.ts';
+import { SbbStepElement } from '../step/step.component.ts';
+import { SbbStepperElement } from '../stepper/stepper.component.ts';
 declare const SbbStepLabelElement_base: import('../../core/mixins.ts').AbstractConstructor<import('../../icon.ts').SbbIconNameMixinType> & import('../../core/mixins.ts').AbstractConstructor<import('../../core/mixins.ts').SbbDisabledMixinType> & typeof SbbButtonBaseElement;
 /**
  * Combined with a `sbb-stepper`, it displays a step's label.
@@ -10,6 +10,7 @@ declare const SbbStepLabelElement_base: import('../../core/mixins.ts').AbstractC
  * @slot icon - Use this to display an icon in the label bubble.
  */
 export declare class SbbStepLabelElement extends SbbStepLabelElement_base {
+    static readonly elementName: string;
     static readonly role = "tab";
     static styles: CSSResultGroup;
     /** The step controlled by the label. */

package/development/stepper/step-label/step-label.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-label.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/stepper/step-label/step-label.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAQ,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAKnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;;AAMvD;;;;;GAKG;AACH,qBAEM,mBAAoB,SAAQ,wBAAwD;IACxF,gBAAgC,IAAI,SAAS;IAC7C,OAAuB,MAAM,EAAE,cAAc,CAA4B;IAEzE,wCAAwC;IACxC,IAAW,IAAI,IAAI,cAAc,GAAG,IAAI,CAEvC;IACD,OAAO,CAAC,KAAK,CAA+B;IAE5C,IAAW,OAAO,IAAI,iBAAiB,GAAG,IAAI,CAE7C;IAED,IAAoB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAM1C;IACD,IAAoB,QAAQ,IAAI,OAAO,CAEtC;IAED,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,aAAa,CAAC,CAAS;;IAmC/B,OAAO,CAAC,6BAA6B;IASrB,iBAAiB,IAAI,IAAI;IASzC;;;OAGG;IACI,MAAM,IAAI,IAAI;IAMrB;;;OAGG;IACI,QAAQ,IAAI,IAAI;IAMvB;;;OAGG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,GAAG,IAAI;IAQjF,OAAO,CAAC,WAAW;IAkBnB;;;;OAIG;IACI,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;cAIjB,MAAM,IAAI,cAAc;CAQ5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,gBAAgB,EAAE,mBAAmB,CAAC;KACvC;CACF"}
+{"version":3,"file":"step-label.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/stepper/step-label/step-label.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAQ,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAErE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAKnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;;AAMzE;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,wBAAwD;IAC/F,gBAAgC,WAAW,EAAE,MAAM,CAAoB;IACvE,gBAAgC,IAAI,SAAS;IAC7C,OAAuB,MAAM,EAAE,cAAc,CAA4B;IAEzE,wCAAwC;IACxC,IAAW,IAAI,IAAI,cAAc,GAAG,IAAI,CAEvC;IACD,OAAO,CAAC,KAAK,CAA+B;IAE5C,IAAW,OAAO,IAAI,iBAAiB,GAAG,IAAI,CAE7C;IAED,IAAoB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAM1C;IACD,IAAoB,QAAQ,IAAI,OAAO,CAEtC;IAED,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,aAAa,CAAC,CAAS;;IAmC/B,OAAO,CAAC,6BAA6B;IASrB,iBAAiB,IAAI,IAAI;IASzC;;;OAGG;IACI,MAAM,IAAI,IAAI;IAMrB;;;OAGG;IACI,QAAQ,IAAI,IAAI;IAMvB;;;OAGG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,GAAG,IAAI;IAQjF,OAAO,CAAC,WAAW;IAkBnB;;;;OAIG;IACI,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;cAIjB,MAAM,IAAI,cAAc;CAQ5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,gBAAgB,EAAE,mBAAmB,CAAC;KACvC;CACF"}