@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771859294

package/development/autocomplete/autocomplete.component.d.ts

@@ -0,0 +1,30 @@
+import { SbbOptionElement } from '../option.ts';
+import { SbbAutocompleteBaseElement } from './autocomplete-base-element.ts';
+/**
+ * Combined with a native input, it displays a panel with a list of available options.
+ *
+ * @slot - Use the unnamed slot to add `sbb-option` or `sbb-optgroup` elements to the `sbb-autocomplete`.
+ * @cssprop [--sbb-autocomplete-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+ * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+ * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+ * @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.
+ * If the calculated remaining space is smaller, the value gets ignored.
+ */
+export declare class SbbAutocompleteElement<T = string> extends SbbAutocompleteBaseElement<T> {
+    static readonly role: string | null;
+    protected overlayId: string;
+    protected panelRole: string;
+    protected get options(): SbbOptionElement<T>[];
+    protected syncNegative(): void;
+    protected openedPanelKeyboardInteraction(event: KeyboardEvent): void;
+    protected selectByKeyboard(event: KeyboardEvent): void;
+    protected setNextActiveOption(event?: KeyboardEvent): void;
+    protected resetActiveElement(): void;
+    protected setTriggerAttributes(element: HTMLInputElement): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-autocomplete': SbbAutocompleteElement;
+    }
+}
+//# sourceMappingURL=autocomplete.component.d.ts.map

package/development/autocomplete/autocomplete.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/autocomplete/autocomplete.component.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAwB,MAAM,cAAc,CAAC;AAE3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAU5E;;;;;;;;;GASG;AACH,qBAEM,sBAAsB,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,0BAA0B,CAAC,CAAC,CAAC;IAC5E,gBAAgC,IAAI,gBAAqC;IACzE,SAAS,CAAC,SAAS,SAAkC;IACrD,SAAS,CAAC,SAAS,SAAa;IAEhC,SAAS,KAAK,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAE7C;IAED,SAAS,CAAC,YAAY,IAAI,IAAI;IAM9B,SAAS,CAAC,8BAA8B,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAgBpE,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAStD,SAAS,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,IAAI;IAkC1D,SAAS,CAAC,kBAAkB,IAAI,IAAI;IAMpC,SAAS,CAAC,oBAAoB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;CAGhE;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,kBAAkB,EAAE,sBAAsB,CAAC;KAC5C;CACF"}

package/development/autocomplete/autocomplete.component.js

@@ -0,0 +1,88 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { customElement } from "lit/decorators.js";
+import { getNextElementIndex } from "../core/a11y.js";
+import { isSafari } from "../core/dom.js";
+import { setAriaComboBoxAttributes } from "../core/overlay.js";
+import { SbbAutocompleteBaseElement } from "./autocomplete-base-element.js";
+let nextId = 0;
+const ariaRoleOnHost = isSafari;
+let SbbAutocompleteElement = (() => {
+  var _a;
+  let _classDecorators = [customElement("sbb-autocomplete")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbAutocompleteBaseElement;
+  _a = class extends _classSuper {
+    constructor() {
+      super(...arguments);
+      this.overlayId = `sbb-autocomplete-${++nextId}`;
+      this.panelRole = "listbox";
+    }
+    get options() {
+      return Array.from(this.querySelectorAll?.("sbb-option") ?? []);
+    }
+    syncNegative() {
+      this.querySelectorAll?.("sbb-divider, sbb-option-hint").forEach((el) => el.negative = this.negative);
+    }
+    openedPanelKeyboardInteraction(event) {
+      if (!this.isOpen) {
+        return;
+      }
+      switch (event.key) {
+        case "Enter":
+          this.selectByKeyboard(event);
+          break;
+        case "ArrowDown":
+        case "ArrowUp":
+          this.setNextActiveOption(event);
+          break;
+      }
+    }
+    selectByKeyboard(event) {
+      if (this.activeOption) {
+        event.preventDefault();
+        this.activeOption["selectViaUserInteraction"](true);
+      }
+    }
+    setNextActiveOption(event) {
+      const enabledOptions = this.options.filter((opt) => !opt.matches(":is(:state(disabled),[state--disabled])"));
+      this.activeOption?.setActive(false);
+      this.triggerElement?.removeAttribute("aria-activedescendant");
+      if (!enabledOptions.length) {
+        this.activeOption = null;
+        return;
+      }
+      const activeItemIndex = this.activeOption ? enabledOptions.indexOf(this.activeOption) : -1;
+      const next = getNextElementIndex(event, activeItemIndex, enabledOptions.length);
+      this.activeOption = enabledOptions[next];
+      this.activeOption.setActive(true);
+      this.triggerElement?.setAttribute("aria-activedescendant", this.activeOption.id);
+      this.activeOption.scrollIntoView({ block: "nearest" });
+      if (event) {
+        event.preventDefault();
+      }
+      if (this.autoSelectActiveOption && event) {
+        this.setPendingSelection(this.activeOption);
+      }
+    }
+    resetActiveElement() {
+      this.activeOption?.setActive(false);
+      this.triggerElement?.removeAttribute("aria-activedescendant");
+      this.activeOption = null;
+    }
+    setTriggerAttributes(element) {
+      setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false);
+    }
+  }, _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 = ariaRoleOnHost ? "listbox" : null, __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+export {
+  SbbAutocompleteElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"autocomplete.component.js","sources":["../../../../src/elements/autocomplete/autocomplete.component.ts"],"sourcesContent":["import { customElement } from 'lit/decorators.js';\n\nimport { getNextElementIndex } from '../core/a11y.ts';\nimport { isSafari } from '../core/dom.ts';\nimport { setAriaComboBoxAttributes } from '../core/overlay.ts';\nimport type { SbbDividerElement } from '../divider/divider.component.ts';\nimport type { SbbOptionElement, SbbOptionHintElement } from '../option.ts';\n\nimport { SbbAutocompleteBaseElement } from './autocomplete-base-element.ts';\n\nlet nextId = 0;\n\n/**\n * On Safari, the aria role 'listbox' must be on the host element, or else VoiceOver won't work at all.\n * On the other hand, JAWS and NVDA need the role to be \"closer\" to the options, or else optgroups won't work.\n */\nconst ariaRoleOnHost = isSafari;\n\n/**\n * Combined with a native input, it displays a panel with a list of available options.\n *\n * @slot - Use the unnamed slot to add `sbb-option` or `sbb-optgroup` elements to the `sbb-autocomplete`.\n * @cssprop [--sbb-autocomplete-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n * @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.\n * If the calculated remaining space is smaller, the value gets ignored.\n */\nexport\n@customElement('sbb-autocomplete')\nclass SbbAutocompleteElement<T = string> extends SbbAutocompleteBaseElement<T> {\n  public static override readonly role = ariaRoleOnHost ? 'listbox' : null;\n  protected overlayId = `sbb-autocomplete-${++nextId}`;\n  protected panelRole = 'listbox';\n\n  protected get options(): SbbOptionElement<T>[] {\n    return Array.from(this.querySelectorAll?.<SbbOptionElement<T>>('sbb-option') ?? []);\n  }\n\n  protected syncNegative(): void {\n    this.querySelectorAll?.<SbbDividerElement | SbbOptionHintElement>(\n      'sbb-divider, sbb-option-hint',\n    ).forEach((el) => (el.negative = this.negative));\n  }\n\n  protected openedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (!this.isOpen) {\n      return;\n    }\n    switch (event.key) {\n      case 'Enter':\n        this.selectByKeyboard(event);\n        break;\n\n      case 'ArrowDown':\n      case 'ArrowUp':\n        this.setNextActiveOption(event);\n        break;\n    }\n  }\n\n  protected selectByKeyboard(event: KeyboardEvent): void {\n    if (this.activeOption) {\n      // We are currently selecting an option and therefore the Enter press shouldn't trigger a form submit\n      event.preventDefault();\n\n      this.activeOption['selectViaUserInteraction'](true);\n    }\n  }\n\n  protected setNextActiveOption(event?: KeyboardEvent): void {\n    const enabledOptions = this.options.filter((opt) => !opt.matches(':state(disabled)'));\n\n    // Reset potentially active option\n    this.activeOption?.setActive(false);\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n\n    if (!enabledOptions.length) {\n      this.activeOption = null;\n      return;\n    }\n\n    const activeItemIndex = this.activeOption\n      ? enabledOptions.indexOf(this.activeOption as SbbOptionElement<T>)\n      : -1;\n\n    // Get and activate the next active option\n    const next = getNextElementIndex(event, activeItemIndex, enabledOptions.length);\n    this.activeOption = enabledOptions[next];\n    this.activeOption.setActive(true);\n    this.triggerElement?.setAttribute('aria-activedescendant', this.activeOption.id);\n    this.activeOption.scrollIntoView({ block: 'nearest' });\n\n    // Moving the active option should not move the input cursor (caret)\n    if (event) {\n      event.preventDefault();\n    }\n\n    // If 'autoSelectActiveOption' and is triggered from a keyboard event\n    if (this.autoSelectActiveOption && event) {\n      this.setPendingSelection(this.activeOption);\n    }\n  }\n\n  protected resetActiveElement(): void {\n    this.activeOption?.setActive(false);\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n    this.activeOption = null;\n  }\n\n  protected setTriggerAttributes(element: HTMLInputElement): void {\n    setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false);\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-autocomplete': SbbAutocompleteElement;\n  }\n}\n"],"names":[],"mappings":";;;;;;AAUA,IAAI,SAAS;AAMb,MAAM,iBAAiB;IAcjB,0BAAsB,MAAA;;0BAD3B,cAAc,kBAAkB,CAAC;;;;oBACe;AAAR,EAAA,mBAAQ,YAA6B;AAAA;;AAElE,WAAA,YAAY,oBAAoB,EAAE,MAAM;AACxC,WAAA,YAAY;AAAA,IAgFxB;AAAA,IA9EE,IAAc,UAAO;AACnB,aAAO,MAAM,KAAK,KAAK,mBAAwC,YAAY,KAAK,EAAE;AAAA,IACpF;AAAA,IAEU,eAAY;AACpB,WAAK,mBACH,8BAA8B,EAC9B,QAAQ,CAAC,OAAQ,GAAG,WAAW,KAAK,QAAS;AAAA,IACjD;AAAA,IAEU,+BAA+B,OAAoB;AAC3D,UAAI,CAAC,KAAK,QAAQ;AAChB;AAAA,MACF;AACA,cAAQ,MAAM,KAAA;AAAA,QACZ,KAAK;AACH,eAAK,iBAAiB,KAAK;AAC3B;AAAA,QAEF,KAAK;AAAA,QACL,KAAK;AACH,eAAK,oBAAoB,KAAK;AAC9B;AAAA,MAAA;AAAA,IAEN;AAAA,IAEU,iBAAiB,OAAoB;AAC7C,UAAI,KAAK,cAAc;AAErB,cAAM,eAAA;AAEN,aAAK,aAAa,0BAA0B,EAAE,IAAI;AAAA,MACpD;AAAA,IACF;AAAA,IAEU,oBAAoB,OAAqB;AACjD,YAAM,iBAAiB,KAAK,QAAQ,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,yCAAkB,CAAC;AAGpF,WAAK,cAAc,UAAU,KAAK;AAClC,WAAK,gBAAgB,gBAAgB,uBAAuB;AAE5D,UAAI,CAAC,eAAe,QAAQ;AAC1B,aAAK,eAAe;AACpB;AAAA,MACF;AAEA,YAAM,kBAAkB,KAAK,eACzB,eAAe,QAAQ,KAAK,YAAmC,IAC/D;AAGJ,YAAM,OAAO,oBAAoB,OAAO,iBAAiB,eAAe,MAAM;AAC9E,WAAK,eAAe,eAAe,IAAI;AACvC,WAAK,aAAa,UAAU,IAAI;AAChC,WAAK,gBAAgB,aAAa,yBAAyB,KAAK,aAAa,EAAE;AAC/E,WAAK,aAAa,eAAe,EAAE,OAAO,WAAW;AAGrD,UAAI,OAAO;AACT,cAAM,eAAA;AAAA,MACR;AAGA,UAAI,KAAK,0BAA0B,OAAO;AACxC,aAAK,oBAAoB,KAAK,YAAY;AAAA,MAC5C;AAAA,IACF;AAAA,IAEU,qBAAkB;AAC1B,WAAK,cAAc,UAAU,KAAK;AAClC,WAAK,gBAAgB,gBAAgB,uBAAuB;AAC5D,WAAK,eAAe;AAAA,IACtB;AAAA,IAEU,qBAAqB,SAAyB;AACtD,gCAA0B,SAAS,iBAAiB,KAAK,KAAK,KAAK,WAAW,KAAK;AAAA,IACrF;AAAA;;AAlFF,iBAAA,MAAA,mBAAA,EAAA,OAAA,WAAA,GAAA,kBAAA,EAAA,MAAA,SAAA,MAAA,WAAA,MAAA,UAAA,UAAA,GAAA,MAAA,uBAAA;;;QACkC,GAAA,OAAO,iBAAiB,YAAY,MADhE,kBAAA,YAAA,uBAAA,GAAmC;;;"}

package/development/autocomplete.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @entrypoint
+ */
+export * from './autocomplete/autocomplete.component.ts';
+export * from './autocomplete/autocomplete-base-element.ts';
+//# sourceMappingURL=autocomplete.d.ts.map

package/development/autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../../src/elements/autocomplete.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,0CAA0C,CAAC;AACzD,cAAc,6CAA6C,CAAC"}

package/development/autocomplete.js

@@ -0,0 +1,7 @@
+import { SbbAutocompleteElement } from "./autocomplete/autocomplete.component.js";
+import { SbbAutocompleteBaseElement } from "./autocomplete/autocomplete-base-element.js";
+export {
+  SbbAutocompleteBaseElement,
+  SbbAutocompleteElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7In0=

package/development/breadcrumb/breadcrumb/breadcrumb.component.d.ts

@@ -0,0 +1,20 @@
+import { CSSResultGroup, TemplateResult } from 'lit';
+import { SbbLinkBaseElement } from '../../core/base-elements.ts';
+declare const SbbBreadcrumbElement_base: import('../../core/mixins.ts').AbstractConstructor<import('../../icon.ts').SbbIconNameMixinType> & import('../../core/mixins.ts').AbstractConstructor<import('../../core/mixins.ts').SbbHydrationMixinType> & typeof SbbLinkBaseElement;
+/**
+ * It displays a link to a page; used within a `sbb-breadcrumb-group` it can display the path to the current page.
+ *
+ * @slot - Use the unnamed slot to add content to the breadcrumb.
+ * @slot icon - Use this to display an icon as breadcrumb.
+ */
+export declare class SbbBreadcrumbElement extends SbbBreadcrumbElement_base {
+    static styles: CSSResultGroup;
+    protected renderTemplate(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-breadcrumb': SbbBreadcrumbElement;
+    }
+}
+export {};
+//# sourceMappingURL=breadcrumb.component.d.ts.map

package/development/breadcrumb/breadcrumb/breadcrumb.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breadcrumb.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/breadcrumb/breadcrumb/breadcrumb.component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAI1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;;AAOjE;;;;;GAKG;AACH,qBAEM,oBAAqB,SAAQ,yBAAuD;IACxF,OAAuB,MAAM,EAAE,cAAc,CAA4B;cAEtD,cAAc,IAAI,cAAc;CAQpD;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,gBAAgB,EAAE,oBAAoB,CAAC;KACxC;CACF"}

package/development/breadcrumb/breadcrumb/breadcrumb.component.js

@@ -0,0 +1,91 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { customElement } 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 { boxSizingStyles } from "../../core/styles.js";
+import { SbbIconNameMixin } from "../../icon.js";
+import { css } from "lit";
+const style = css`:host {
+  display: flex;
+}
+
+@media (any-hover: hover) {
+  :host(:hover) {
+    --sbb-breadcrumb-color: var(--sbb-breadcrumb-color-hover);
+  }
+}
+:host(:is(:active, :is(:state(active),[state--active]))) {
+  --sbb-breadcrumb-color: var(--sbb-breadcrumb-color-active);
+}
+
+.sbb-breadcrumb {
+  --sbb-link-text-decoration-line: none;
+  color: var(--sbb-link-color-normal);
+  text-decoration-line: var(--sbb-link-text-decoration-line, underline);
+  text-decoration-thickness: 0.0625rem;
+  text-underline-offset: 0.3125em;
+}
+@media (forced-colors: active) {
+  .sbb-breadcrumb {
+    text-decoration: underline;
+  }
+}
+.sbb-breadcrumb {
+  display: flex;
+  cursor: var(--sbb-cursor-pointer);
+  gap: var(--sbb-breadcrumb-gap);
+  color: var(--sbb-breadcrumb-color);
+  align-items: center;
+  overflow: hidden;
+  outline: none;
+  font-size: var(--sbb-breadcrumb-font-size);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+}
+.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;
+}
+:host(:not(:is(:state(slotted),[state--slotted]))) .sbb-breadcrumb__label {
+  display: none;
+}
+
+slot[name=icon] .sbb-breadcrumb__icon,
+slot[name=icon] ::slotted(*) {
+  flex-shrink: 0;
+}`;
+let SbbBreadcrumbElement = (() => {
+  var _a;
+  let _classDecorators = [customElement("sbb-breadcrumb")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbIconNameMixin(SbbHydrationMixin(SbbLinkBaseElement));
+  _a = class extends _classSuper {
+    renderTemplate() {
+      return html`
+      ${this.renderIconSlot("sbb-breadcrumb__icon")}
+      <span class="sbb-breadcrumb__label">
+        <slot></slot>
+      </span>
+    `;
+    }
+  }, _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.styles = [boxSizingStyles, 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.component.d.ts

@@ -0,0 +1,50 @@
+import { CSSResultGroup, LitElement, PropertyValues, TemplateResult } from 'lit';
+import { WithListChildren } from '../../core/mixins.ts';
+import { SbbBreadcrumbElement } from '../breadcrumb.ts';
+declare const SbbBreadcrumbGroupElement_base: import('../../core/mixins.ts').AbstractConstructor<import('../../core/mixins.ts').SbbElementInternalsMixinType> & import('../../core/mixins.ts').AbstractConstructor<import('../../core/mixins.ts').SbbNamedSlotListMixinType<SbbBreadcrumbElement>> & typeof LitElement & import('../../core/mixins.ts').SbbElementInternalsConstructor;
+/**
+ * It can be used as a container for one or more `sbb-breadcrumb` component.
+ *
+ * @slot - Use the unnamed slot to add `sbb-breadcrumb` elements.
+ */
+export declare class SbbBreadcrumbGroupElement extends SbbBreadcrumbGroupElement_base {
+    static readonly role = "navigation";
+    static styles: CSSResultGroup;
+    protected readonly listChildLocalNames: string[];
+    /** The state of the breadcrumb group. */
+    private set _state(value);
+    private get _state();
+    private _stateInternal;
+    private _resizeObserver;
+    private _language;
+    private _markForFocus;
+    constructor();
+    private _handleKeyDown;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    protected willUpdate(changedProperties: PropertyValues<WithListChildren<this>>): void;
+    protected updated(changedProperties: PropertyValues<WithListChildren<this>>): void;
+    /** Apply the aria-current attribute to the last sbb-breadcrumb element. */
+    private _syncBreadcrumbs;
+    /**
+     * Sets the focus on the correct element when the ellipsis breadcrumb is displayed and the user is navigating with keyboard's arrows.
+     */
+    private _focusNextCollapsed;
+    private _focusNext;
+    /**
+     * 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.
+     */
+    private _expandBreadcrumbs;
+    /** Evaluate if the expanded breadcrumb element fits in page width, otherwise it needs ellipsis */
+    private _evaluateCollapsedState;
+    private _renderCollapsed;
+    private _renderExpanded;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-breadcrumb-group': SbbBreadcrumbGroupElement;
+    }
+}
+export {};
+//# sourceMappingURL=breadcrumb-group.component.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"breadcrumb-group.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/breadcrumb/breadcrumb-group/breadcrumb-group.component.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,cAAc,EAEnB,UAAU,EAEV,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;AAUb,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAI7D,OAAO,eAAe,CAAC;;AAIvB;;;;GAIG;AACH,qBAEM,yBAA0B,SAAQ,8BAEvC;IACC,gBAAgC,IAAI,gBAAgB;IACpD,OAAuB,MAAM,EAAE,cAAc,CAA4B;IACzE,mBAA4B,mBAAmB,WAAsB;IAErE,yCAAyC;IAEzC,OAAO,KAAK,MAAM,QAQjB;IACD,OAAO,KAAK,MAAM,GAEjB;IACD,OAAO,CAAC,cAAc,CAAkD;IAExE,OAAO,CAAC,eAAe,CAIpB;IACH,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,aAAa,CAAS;;IAO9B,OAAO,CAAC,cAAc;cAiBH,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;cAO3D,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI;cAQ3E,OAAO,CAAC,iBAAiB,EAAE,cAAc,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI;IAa3F,2EAA2E;IAC3E,OAAO,CAAC,gBAAgB;IAaxB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,UAAU;IAYlB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAK1B,kGAAkG;IAClG,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,eAAe;cAgBJ,MAAM,IAAI,cAAc;CAQ5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,sBAAsB,EAAE,yBAAyB,CAAC;KACnD;CACF"}

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

@@ -0,0 +1,269 @@
+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 { i18nBreadcrumbEllipsisButtonLabel } from "../../core/i18n.js";
+import { SbbElementInternalsMixin, SbbNamedSlotListMixin } from "../../core/mixins.js";
+import { boxSizingStyles } from "../../core/styles.js";
+import "../../icon.js";
+const style = css`:host {
+  display: block;
+}
+
+:host(:is(:state(loaded),[state--loaded])) {
+  --sbb-breadcrumb-group-visibility: visible;
+}
+
+:host(:is(:is(:state(state-collapsed),[state--state-collapsed]), :is(:state(state-manually-expanded),[state--state-manually-expanded]))) {
+  --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-breadcrumb-group-ellipsis-color);
+}
+
+#sbb-breadcrumb-ellipsis {
+  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-text-font-size-xxs);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+  font-size: var(--sbb-text-font-size);
+  line-height: 0;
+  letter-spacing: 0.01em;
+  font-size: var(--sbb-text-font-size-xxs);
+  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: var(--sbb-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-2);
+    --sbb-breadcrumb-group-ellipsis-background-color: var(--sbb-background-color-3);
+  }
+}
+@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")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbElementInternalsMixin(SbbNamedSlotListMixin(LitElement));
+  let _instanceExtraInitializers = [];
+  let _set__state_decorators;
+  _a = class extends _classSuper {
+    /** The state of the breadcrumb group. */
+    set _state(state2) {
+      if (this._stateInternal) {
+        this.internals.states.delete(`state-${this._stateInternal}`);
+      }
+      this._stateInternal = state2;
+      if (this._stateInternal) {
+        this.internals.states.add(`state-${this._stateInternal}`);
+      }
+    }
+    get _state() {
+      return this._stateInternal;
+    }
+    constructor() {
+      super();
+      this.listChildLocalNames = (__runInitializers(this, _instanceExtraInitializers), ["sbb-breadcrumb"]);
+      this._stateInternal = null;
+      this._resizeObserver = new ResizeController(this, {
+        target: null,
+        skipInitial: true,
+        callback: () => this._evaluateCollapsedState()
+      });
+      this._language = new SbbLanguageController(this);
+      this._markForFocus = false;
+      this.addEventListener?.("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.internals.states.add("loaded");
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("listChildren")) {
+        this._syncBreadcrumbs();
+      }
+    }
+    updated(changedProperties) {
+      super.updated(changedProperties);
+      if (changedProperties.has("listChildren")) {
+        Promise.resolve().then(() => this._evaluateCollapsedState());
+      }
+      if (this._markForFocus && sbbInputModalityDetector.mostRecentModality === "keyboard") {
+        this.listChildren[1]?.focus();
+        this._markForFocus = false;
+      }
+    }
+    /** Apply the aria-current attribute to the last sbb-breadcrumb element. */
+    _syncBreadcrumbs() {
+      this.listChildren.slice(0, -1).filter((c) => c.hasAttribute("accessibility-current")).forEach((c) => c.removeAttribute("accessibility-current"));
+      this.listChildren[this.listChildren.length - 1]?.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) {
+      const current = breadcrumbs.findIndex((e) => e === document.activeElement || e === this.shadowRoot.activeElement);
+      const nextIndex = getNextElementIndex(evt, current, breadcrumbs.length);
+      breadcrumbs[nextIndex]?.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.role = "navigation", _a.styles = [boxSizingStyles, style], __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+export {
+  SbbBreadcrumbGroupElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"breadcrumb-group.component.js","sources":["../../../../../src/elements/breadcrumb/breadcrumb-group/breadcrumb-group.component.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.ts';\nimport { SbbLanguageController } from '../../core/controllers.ts';\nimport { i18nBreadcrumbEllipsisButtonLabel } from '../../core/i18n.ts';\nimport {\n  SbbElementInternalsMixin,\n  SbbNamedSlotListMixin,\n  type WithListChildren,\n} from '../../core/mixins.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport type { SbbBreadcrumbElement } from '../breadcrumb.ts';\n\nimport style from './breadcrumb-group.scss?lit&inline';\n\nimport '../../icon.ts';\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')\nclass SbbBreadcrumbGroupElement extends SbbElementInternalsMixin(\n  SbbNamedSlotListMixin<SbbBreadcrumbElement, typeof LitElement>(LitElement),\n) {\n  public static override readonly role = 'navigation';\n  public static override styles: CSSResultGroup = [boxSizingStyles, 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    if (this._stateInternal) {\n      this.internals.states.delete(`state-${this._stateInternal}`);\n    }\n    this._stateInternal = state;\n    if (this._stateInternal) {\n      this.internals.states.add(`state-${this._stateInternal}`);\n    }\n  }\n  private get _state(): 'collapsed' | 'manually-expanded' | null {\n    return this._stateInternal;\n  }\n  private _stateInternal: 'collapsed' | 'manually-expanded' | null = null;\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.internals.states.add('loaded');\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"],"mappings":"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"}

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

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

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

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

package/development/breadcrumb/breadcrumb-group.js

@@ -0,0 +1,5 @@
+import { SbbBreadcrumbGroupElement } from "./breadcrumb-group/breadcrumb-group.component.js";
+export {
+  SbbBreadcrumbGroupElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJlYWRjcnVtYi1ncm91cC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7In0=