@sbb-esta/lyne-elements 2.5.1 → 2.7.0

package/development/breadcrumb/breadcrumb/breadcrumb.js

@@ -0,0 +1,136 @@
+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 { customElement, state } from "lit/decorators.js";
+import { html } from "lit/static-html.js";
+import { SbbLinkBaseElement } from "../../core/base-elements.js";
+import { SbbHydrationMixin } from "../../core/mixins.js";
+import { SbbIconNameMixin } from "../../icon.js";
+import { css } from "lit";
+const style = css`*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  display: flex;
+  --sbb-breadcrumb-color: var(--sbb-color-granite);
+}
+
+@media (any-hover: hover) {
+  :host(:hover) {
+    --sbb-breadcrumb-color: var(--sbb-color-charcoal);
+  }
+}
+:host(:is(:active, [data-active])) {
+  --sbb-breadcrumb-color: var(--sbb-color-anthracite);
+}
+
+.sbb-breadcrumb {
+  --sbb-link-text-decoration: none;
+  --sbb-text-font-size: var(--sbb-font-size-text-xs);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  color: var(--sbb-link-color-normal);
+  text-decoration-line: var(--sbb-link-text-decoration, underline);
+  text-decoration-color: var(--sbb-link-text-decoration-color);
+  text-decoration-thickness: 0.0625rem;
+  text-underline-offset: 0.3125em;
+  user-select: none;
+}
+@media (forced-colors: active) {
+  .sbb-breadcrumb {
+    text-decoration: underline;
+  }
+}
+.sbb-breadcrumb {
+  display: flex;
+  cursor: pointer;
+  gap: var(--sbb-spacing-fixed-2x);
+  color: var(--sbb-breadcrumb-color);
+  align-items: center;
+  overflow: hidden;
+  outline: none;
+}
+@media (forced-colors: active) {
+  .sbb-breadcrumb {
+    --sbb-breadcrumb-color: ButtonText;
+  }
+}
+.sbb-breadcrumb:focus-visible {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+  border-radius: var(--sbb-border-radius-2x);
+}
+
+.sbb-breadcrumb__label {
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+slot[name=icon] .sbb-breadcrumb__icon,
+slot[name=icon] ::slotted(*) {
+  flex-shrink: 0;
+}`;
+let SbbBreadcrumbElement = (() => {
+  var __hasText_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-breadcrumb")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbIconNameMixin(SbbHydrationMixin(SbbLinkBaseElement));
+  let __hasText_decorators;
+  let __hasText_initializers = [];
+  let __hasText_extraInitializers = [];
+  _a = class extends _classSuper {
+    constructor() {
+      super(...arguments);
+      __privateAdd(this, __hasText_accessor_storage, __runInitializers(this, __hasText_initializers, false));
+      __runInitializers(this, __hasText_extraInitializers);
+    }
+    get _hasText() {
+      return __privateGet(this, __hasText_accessor_storage);
+    }
+    set _hasText(value) {
+      __privateSet(this, __hasText_accessor_storage, value);
+    }
+    _handleSlotchange() {
+      this._hasText = Array.from(this.childNodes ?? []).some((n) => {
+        var _a2;
+        return !n.slot && ((_a2 = n.textContent) == null ? void 0 : _a2.trim());
+      });
+    }
+    renderTemplate() {
+      return html`
+      ${this.renderIconSlot("sbb-breadcrumb__icon")}
+      <span class="sbb-breadcrumb__label" ?hidden=${!this._hasText}>
+        <slot @slotchange=${this._handleSlotchange}></slot>
+      </span>
+    `;
+    }
+  }, __hasText_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    __hasText_decorators = [state()];
+    __esDecorate(_a, null, __hasText_decorators, { kind: "accessor", name: "_hasText", static: false, private: false, access: { has: (obj) => "_hasText" in obj, get: (obj) => obj._hasText, set: (obj, value) => {
+      obj._hasText = value;
+    } }, metadata: _metadata }, __hasText_initializers, __hasText_extraInitializers);
+    __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.styles = style, __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+export {
+  SbbBreadcrumbElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/breadcrumb/breadcrumb-group/breadcrumb-group.js

@@ -0,0 +1,281 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { ResizeController } from "@lit-labs/observers/resize-controller.js";
+import { css, LitElement, html, nothing } from "lit";
+import { customElement, state } from "lit/decorators.js";
+import { isArrowKeyPressed, sbbInputModalityDetector, getNextElementIndex } from "../../core/a11y.js";
+import { SbbLanguageController } from "../../core/controllers.js";
+import { hostAttributes } from "../../core/decorators.js";
+import { setOrRemoveAttribute } from "../../core/dom.js";
+import { i18nBreadcrumbEllipsisButtonLabel } from "../../core/i18n.js";
+import { SbbNamedSlotListMixin } from "../../core/mixins.js";
+import "../../icon.js";
+const style = css`*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-breadcrumb-group-wrap: nowrap;
+  --sbb-breadcrumb-group-visibility: hidden;
+  display: block;
+}
+
+:host([data-loaded]) {
+  --sbb-breadcrumb-group-visibility: visible;
+}
+
+:host([data-state]) {
+  --sbb-breadcrumb-group-wrap: wrap;
+}
+
+.sbb-breadcrumb-group {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  font-size: inherit;
+  display: flex;
+  flex-wrap: var(--sbb-breadcrumb-group-wrap);
+  column-gap: var(--sbb-spacing-fixed-1x);
+  visibility: var(--sbb-breadcrumb-group-visibility);
+}
+
+.sbb-breadcrumb-group__item {
+  flex: 0 0 auto;
+  display: flex;
+  column-gap: var(--sbb-spacing-fixed-1x);
+}
+
+.sbb-breadcrumb-group__divider-icon {
+  color: var(--sbb-color-granite);
+}
+
+#sbb-breadcrumb-ellipsis {
+  --sbb-breadcrumb-group-ellipsis-color: var(--sbb-color-granite);
+  --sbb-breadcrumb-group-ellipsis-background-color: transparent;
+  --sbb-breadcrumb-group-ellipsis-border-width: var(--sbb-border-width-1x);
+  --sbb-breadcrumb-group-ellipsis-border-color: var(--sbb-color-silver);
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  box-sizing: border-box;
+  margin: 0;
+  outline: none;
+  border: none;
+  border-radius: 0;
+  padding: 0;
+  background: none;
+  -webkit-tap-highlight-color: transparent;
+  color: inherit;
+  --sbb-text-font-size: var(--sbb-font-size-text-xxs);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  line-height: 0;
+  letter-spacing: 0.01em;
+  width: var(--sbb-size-icon-ui-small);
+  height: var(--sbb-size-icon-ui-small);
+  border: var(--sbb-breadcrumb-group-ellipsis-border-width) solid var(--sbb-breadcrumb-group-ellipsis-border-color);
+  border-radius: 50%;
+  padding-block-end: 0.5em;
+  cursor: pointer;
+  color: var(--sbb-breadcrumb-group-ellipsis-color);
+  background-color: var(--sbb-breadcrumb-group-ellipsis-background-color);
+  overflow: hidden;
+}
+@media (forced-colors: active) {
+  #sbb-breadcrumb-ellipsis {
+    --sbb-breadcrumb-group-ellipsis-border-width: var(--sbb-border-width-2x);
+    --sbb-breadcrumb-group-ellipsis-border-color: CanvasText;
+  }
+}
+@media (any-hover: hover) {
+  #sbb-breadcrumb-ellipsis:hover {
+    --sbb-breadcrumb-group-ellipsis-color: var(--sbb-color-charcoal);
+    --sbb-breadcrumb-group-ellipsis-background-color: var(--sbb-color-milk);
+  }
+}
+@media (any-hover: hover) and (forced-colors: active) {
+  #sbb-breadcrumb-ellipsis:hover {
+    --sbb-breadcrumb-group-ellipsis-border-color: Highlight;
+  }
+}
+#sbb-breadcrumb-ellipsis:focus-visible {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+}`;
+const MIN_BREADCRUMBS_TO_COLLAPSE = 3;
+let SbbBreadcrumbGroupElement = (() => {
+  var _a;
+  let _classDecorators = [customElement("sbb-breadcrumb-group"), hostAttributes({
+    role: "navigation"
+  })];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbNamedSlotListMixin(LitElement);
+  let _instanceExtraInitializers = [];
+  let _set__state_decorators;
+  _a = class extends _classSuper {
+    /* The state of the breadcrumb group. */
+    set _state(state2) {
+      setOrRemoveAttribute(this, "data-state", state2);
+    }
+    get _state() {
+      return this.getAttribute("data-state");
+    }
+    constructor() {
+      var _a2;
+      super();
+      this.listChildLocalNames = (__runInitializers(this, _instanceExtraInitializers), ["sbb-breadcrumb"]);
+      this._resizeObserver = new ResizeController(this, {
+        target: null,
+        skipInitial: true,
+        callback: () => this._evaluateCollapsedState()
+      });
+      this._language = new SbbLanguageController(this);
+      this._markForFocus = false;
+      (_a2 = this.addEventListener) == null ? void 0 : _a2.call(this, "keydown", (e) => this._handleKeyDown(e));
+    }
+    _handleKeyDown(evt) {
+      if (!this.listChildren.length || // don't trap nested handling
+      evt.target !== this && evt.target.parentElement !== this) {
+        return;
+      }
+      if (isArrowKeyPressed(evt)) {
+        if (this._state === "collapsed") {
+          return this._focusNextCollapsed(evt);
+        }
+        this._focusNext(evt);
+      }
+    }
+    firstUpdated(changedProperties) {
+      super.firstUpdated(changedProperties);
+      this._resizeObserver.observe(this);
+      this.toggleAttribute("data-loaded", true);
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("listChildren")) {
+        this._syncBreadcrumbs();
+      }
+    }
+    updated(changedProperties) {
+      var _a2;
+      super.updated(changedProperties);
+      if (changedProperties.has("listChildren")) {
+        Promise.resolve().then(() => this._evaluateCollapsedState());
+      }
+      if (this._markForFocus && sbbInputModalityDetector.mostRecentModality === "keyboard") {
+        (_a2 = this.listChildren[1]) == null ? void 0 : _a2.focus();
+        this._markForFocus = false;
+      }
+    }
+    /** Apply the aria-current attribute to the last sbb-breadcrumb element. */
+    _syncBreadcrumbs() {
+      var _a2;
+      this.listChildren.slice(0, -1).filter((c) => c.hasAttribute("accessibility-current")).forEach((c) => c.removeAttribute("accessibility-current"));
+      (_a2 = this.listChildren[this.listChildren.length - 1]) == null ? void 0 : _a2.setAttribute("accessibility-current", "page");
+      if (this.listChildren.length < MIN_BREADCRUMBS_TO_COLLAPSE) {
+        this._state = null;
+      }
+    }
+    /**
+     * Sets the focus on the correct element when the ellipsis breadcrumb is displayed and the user is navigating with keyboard's arrows.
+     */
+    _focusNextCollapsed(evt) {
+      const arrayCollapsed = [
+        this.listChildren[0],
+        this.shadowRoot.querySelector("#sbb-breadcrumb-ellipsis"),
+        this.listChildren[this.listChildren.length - 1]
+      ];
+      this._focusNext(evt, arrayCollapsed);
+    }
+    _focusNext(evt, breadcrumbs = this.listChildren) {
+      var _a2;
+      const current = breadcrumbs.findIndex((e) => e === document.activeElement || e === this.shadowRoot.activeElement);
+      const nextIndex = getNextElementIndex(evt, current, breadcrumbs.length);
+      (_a2 = breadcrumbs[nextIndex]) == null ? void 0 : _a2.focus();
+      evt.preventDefault();
+    }
+    /**
+     * Note: due to @State annotation on _state, this method triggers a new render; as a consequence, the focus is moved
+     * to the `body`, so if the ellipsis element has focus, it's asynchronously forced to the first element.
+     */
+    _expandBreadcrumbs() {
+      this._state = "manually-expanded";
+      this._markForFocus = true;
+    }
+    /** Evaluate if the expanded breadcrumb element fits in page width, otherwise it needs ellipsis */
+    _evaluateCollapsedState() {
+      if (!this._state && this.scrollWidth > this.offsetWidth && this.listChildren.length >= MIN_BREADCRUMBS_TO_COLLAPSE) {
+        this._state = "collapsed";
+        this._resizeObserver.hostDisconnected();
+        this.removeController(this._resizeObserver);
+      }
+    }
+    _renderCollapsed() {
+      return html`
+      <li class="sbb-breadcrumb-group__item">
+        <slot name="li-0"></slot>
+      </li>
+      <li class="sbb-breadcrumb-group__item" id="sbb-breadcrumb-group-ellipsis">
+        <sbb-icon
+          name="chevron-small-right-small"
+          class="sbb-breadcrumb-group__divider-icon"
+        ></sbb-icon>
+        <button
+          type="button"
+          id="sbb-breadcrumb-ellipsis"
+          aria-label=${i18nBreadcrumbEllipsisButtonLabel[this._language.current]}
+          aria-expanded="false"
+          @click=${() => this._expandBreadcrumbs()}
+        >
+          ...
+        </button>
+      </li>
+      <li class="sbb-breadcrumb-group__item">
+        <sbb-icon
+          name="chevron-small-right-small"
+          class="sbb-breadcrumb-group__divider-icon"
+        ></sbb-icon>
+        <slot name=${`li-${this.listChildren.length - 1}`}></slot>
+      </li>
+    `;
+    }
+    _renderExpanded() {
+      return this.listSlotEntries().map((slot, index, array) => html`
+        <li class="sbb-breadcrumb-group__item">
+          <slot name=${slot.name}></slot>
+          ${index !== array.length - 1 ? html`<sbb-icon
+                name="chevron-small-right-small"
+                class="sbb-breadcrumb-group__divider-icon"
+              ></sbb-icon>` : nothing}
+        </li>
+      `);
+    }
+    render() {
+      return html`
+      <ol class="sbb-breadcrumb-group">
+        ${this._state === "collapsed" ? this._renderCollapsed() : this._renderExpanded()}
+      </ol>
+      ${this.renderHiddenSlot()}
+    `;
+    }
+  }, _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _set__state_decorators = [state()];
+    __esDecorate(_a, null, _set__state_decorators, { kind: "setter", name: "_state", static: false, private: false, access: { has: (obj) => "_state" in obj, set: (obj, value) => {
+      obj._state = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __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.styles = style, __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+export {
+  SbbBreadcrumbGroupElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"breadcrumb-group.js","sources":["../../../../../src/elements/breadcrumb/breadcrumb-group/breadcrumb-group.ts"],"sourcesContent":["import { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  LitElement,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, state } from 'lit/decorators.js';\n\nimport {\n  getNextElementIndex,\n  isArrowKeyPressed,\n  sbbInputModalityDetector,\n} from '../../core/a11y.js';\nimport { SbbLanguageController } from '../../core/controllers.js';\nimport { hostAttributes } from '../../core/decorators.js';\nimport { setOrRemoveAttribute } from '../../core/dom.js';\nimport { i18nBreadcrumbEllipsisButtonLabel } from '../../core/i18n.js';\nimport { SbbNamedSlotListMixin, type WithListChildren } from '../../core/mixins.js';\nimport type { SbbBreadcrumbElement } from '../breadcrumb.js';\n\nimport style from './breadcrumb-group.scss?lit&inline';\n\nimport '../../icon.js';\n\nconst MIN_BREADCRUMBS_TO_COLLAPSE = 3;\n\n/**\n * It can be used as a container for one or more `sbb-breadcrumb` component.\n *\n * @slot - Use the unnamed slot to add `sbb-breadcrumb` elements.\n */\nexport\n@customElement('sbb-breadcrumb-group')\n@hostAttributes({\n  role: 'navigation',\n})\nclass SbbBreadcrumbGroupElement extends SbbNamedSlotListMixin<\n  SbbBreadcrumbElement,\n  typeof LitElement\n>(LitElement) {\n  public static override styles: CSSResultGroup = style;\n  protected override readonly listChildLocalNames = ['sbb-breadcrumb'];\n\n  /* The state of the breadcrumb group. */\n  @state()\n  private set _state(state: 'collapsed' | 'manually-expanded' | null) {\n    setOrRemoveAttribute(this, 'data-state', state);\n  }\n  private get _state(): 'collapsed' | 'manually-expanded' | null {\n    return this.getAttribute('data-state') as 'collapsed' | 'manually-expanded' | null;\n  }\n\n  private _resizeObserver = new ResizeController(this, {\n    target: null,\n    skipInitial: true,\n    callback: () => this._evaluateCollapsedState(),\n  });\n  private _language = new SbbLanguageController(this);\n  private _markForFocus = false;\n\n  public constructor() {\n    super();\n    this.addEventListener?.('keydown', (e) => this._handleKeyDown(e));\n  }\n\n  private _handleKeyDown(evt: KeyboardEvent): void {\n    if (\n      !this.listChildren.length ||\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      if (this._state === 'collapsed') {\n        return this._focusNextCollapsed(evt);\n      }\n      this._focusNext(evt);\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    this._resizeObserver.observe(this);\n    this.toggleAttribute('data-loaded', true);\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<WithListChildren<this>>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('listChildren')) {\n      this._syncBreadcrumbs();\n    }\n  }\n\n  protected override updated(changedProperties: PropertyValues<WithListChildren<this>>): void {\n    super.updated(changedProperties);\n    if (changedProperties.has('listChildren')) {\n      Promise.resolve().then(() => this._evaluateCollapsedState());\n    }\n    if (this._markForFocus && sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n      this.listChildren[1]?.focus();\n\n      // Reset mark for focus\n      this._markForFocus = false;\n    }\n  }\n\n  /** Apply the aria-current attribute to the last sbb-breadcrumb element. */\n  private _syncBreadcrumbs(): void {\n    this.listChildren\n      .slice(0, -1)\n      .filter((c) => c.hasAttribute('accessibility-current'))\n      .forEach((c) => c.removeAttribute('accessibility-current'));\n    this.listChildren[this.listChildren.length - 1]?.setAttribute('accessibility-current', 'page');\n\n    // If it is not expandable, reset state\n    if (this.listChildren.length < MIN_BREADCRUMBS_TO_COLLAPSE) {\n      this._state = null;\n    }\n  }\n\n  /**\n   * Sets the focus on the correct element when the ellipsis breadcrumb is displayed and the user is navigating with keyboard's arrows.\n   */\n  private _focusNextCollapsed(evt: KeyboardEvent): void {\n    const arrayCollapsed: SbbBreadcrumbElement[] = [\n      this.listChildren[0],\n      this.shadowRoot!.querySelector('#sbb-breadcrumb-ellipsis') as SbbBreadcrumbElement,\n      this.listChildren[this.listChildren.length - 1],\n    ];\n    this._focusNext(evt, arrayCollapsed);\n  }\n\n  private _focusNext(\n    evt: KeyboardEvent,\n    breadcrumbs: SbbBreadcrumbElement[] = this.listChildren,\n  ): void {\n    const current: number = breadcrumbs.findIndex(\n      (e) => e === document.activeElement || e === this.shadowRoot!.activeElement,\n    );\n    const nextIndex: number = getNextElementIndex(evt, current, breadcrumbs.length);\n    breadcrumbs[nextIndex]?.focus();\n    evt.preventDefault();\n  }\n\n  /**\n   * Note: due to @State annotation on _state, this method triggers a new render; as a consequence, the focus is moved\n   * to the `body`, so if the ellipsis element has focus, it's asynchronously forced to the first element.\n   */\n  private _expandBreadcrumbs(): void {\n    this._state = 'manually-expanded';\n    this._markForFocus = true;\n  }\n\n  /** Evaluate if the expanded breadcrumb element fits in page width, otherwise it needs ellipsis */\n  private _evaluateCollapsedState(): void {\n    if (\n      !this._state &&\n      this.scrollWidth > this.offsetWidth &&\n      this.listChildren.length >= MIN_BREADCRUMBS_TO_COLLAPSE\n    ) {\n      this._state = 'collapsed';\n      this._resizeObserver.hostDisconnected();\n      this.removeController(this._resizeObserver);\n    }\n  }\n\n  private _renderCollapsed(): TemplateResult {\n    return html`\n      <li class=\"sbb-breadcrumb-group__item\">\n        <slot name=\"li-0\"></slot>\n      </li>\n      <li class=\"sbb-breadcrumb-group__item\" id=\"sbb-breadcrumb-group-ellipsis\">\n        <sbb-icon\n          name=\"chevron-small-right-small\"\n          class=\"sbb-breadcrumb-group__divider-icon\"\n        ></sbb-icon>\n        <button\n          type=\"button\"\n          id=\"sbb-breadcrumb-ellipsis\"\n          aria-label=${i18nBreadcrumbEllipsisButtonLabel[this._language.current]}\n          aria-expanded=\"false\"\n          @click=${() => this._expandBreadcrumbs()}\n        >\n          ...\n        </button>\n      </li>\n      <li class=\"sbb-breadcrumb-group__item\">\n        <sbb-icon\n          name=\"chevron-small-right-small\"\n          class=\"sbb-breadcrumb-group__divider-icon\"\n        ></sbb-icon>\n        <slot name=${`li-${this.listChildren.length - 1}`}></slot>\n      </li>\n    `;\n  }\n\n  private _renderExpanded(): TemplateResult[] {\n    return this.listSlotEntries().map(\n      (slot, index, array) => html`\n        <li class=\"sbb-breadcrumb-group__item\">\n          <slot name=${slot.name}></slot>\n          ${index !== array.length - 1\n            ? html`<sbb-icon\n                name=\"chevron-small-right-small\"\n                class=\"sbb-breadcrumb-group__divider-icon\"\n              ></sbb-icon>`\n            : nothing}\n        </li>\n      `,\n    );\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <ol class=\"sbb-breadcrumb-group\">\n        ${this._state === 'collapsed' ? this._renderCollapsed() : this._renderExpanded()}\n      </ol>\n      ${this.renderHiddenSlot()}\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-breadcrumb-group': SbbBreadcrumbGroupElement;\n  }\n}\n"],"names":["state","_a"],"mappings":"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"}

package/development/breadcrumb/breadcrumb-group.d.ts

@@ -1,2 +1,5 @@
+/**
+ * @entrypoint
+ */
 export * from './breadcrumb-group/breadcrumb-group.js';
 //# sourceMappingURL=breadcrumb-group.d.ts.map

package/development/breadcrumb/breadcrumb-group.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"breadcrumb-group.d.ts","sourceRoot":"","sources":["../../../../src/elements/breadcrumb/breadcrumb-group.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC"}
+{"version":3,"file":"breadcrumb-group.d.ts","sourceRoot":"","sources":["../../../../src/elements/breadcrumb/breadcrumb-group.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,wCAAwC,CAAC"}