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

package/development/tab-label.component-BbQu5sA-.js

@@ -0,0 +1,233 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbDisabledMixin, SbbElement, SbbPropertyWatcherController, forceType, omitEmptyConverter } from "./core.js";
+import { html as html$1, unsafeStatic } from "lit/static-html.js";
+import { SbbIconNameMixin } from "./icon.pure.js";
+import { tabLabelCommonStyles } from "./tabs/common/styles.js";
+import { SbbTabChangeEvent } from "./tabs/tab-group/tab-group.component.js";
+//#region src/elements/tabs/tab-label/tab-label.scss?inline
+var tab_label_default = ":host {\n  display: inline-block;\n  max-width: 100%;\n  outline: none !important;\n}\n\n.sbb-tab-label {\n  cursor: var(--sbb-tab-label-cursor);\n  user-select: none;\n  -webkit-tap-highlight-color: transparent;\n}\n\n.sbb-tab-label__icon {\n  display: flex;\n  flex-shrink: 0;\n}\n:host(:not(:is(:state(slotted-icon),[state--slotted-icon]), :is(:state(has-icon-name),[state--has-icon-name]))) .sbb-tab-label__icon {\n  display: none;\n}\n\n.sbb-tab-label__text {\n  overflow: hidden;\n  white-space: nowrap;\n  text-overflow: ellipsis;\n}\n:host(:not(:is(:state(slotted),[state--slotted]))) .sbb-tab-label__text {\n  display: none;\n}\n\n.sbb-tab-label__amount {\n  margin: 0;\n  color: var(--sbb-tab-label-amount-color);\n  font-weight: normal;\n  text-decoration: var(--sbb-tab-label-text-decoration);\n}\n:host(:not(:is(:state(slotted-amount),[state--slotted-amount]), [amount])) .sbb-tab-label__amount {\n  display: none;\n}";
+//#endregion
+//#region src/elements/tabs/tab-label/tab-label.component.ts
+/**
+* Combined with a `sbb-tab-group`, it displays a tab's title.
+*
+* @slot - Use the unnamed slot to add content to the tab title.
+* @slot icon - Use this slot to display an icon to the left of the title, by providing the `sbb-icon` component.
+* @slot amount - Provide a number to show an amount to the right of the title.
+*/
+var SbbTabLabelElement = (() => {
+	let _classSuper = SbbDisabledMixin(SbbIconNameMixin(SbbElement));
+	let _level_decorators;
+	let _level_initializers = [];
+	let _level_extraInitializers = [];
+	let _active_decorators;
+	let _active_initializers = [];
+	let _active_extraInitializers = [];
+	let _amount_decorators;
+	let _amount_initializers = [];
+	let _amount_extraInitializers = [];
+	return class SbbTabLabelElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_level_decorators = [property()];
+			_active_decorators = [forceType(), property({
+				reflect: true,
+				type: Boolean
+			})];
+			_amount_decorators = [forceType(), property({
+				reflect: true,
+				converter: omitEmptyConverter
+			})];
+			__esDecorate(this, null, _level_decorators, {
+				kind: "accessor",
+				name: "level",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "level" in obj,
+					get: (obj) => obj.level,
+					set: (obj, value) => {
+						obj.level = value;
+					}
+				},
+				metadata: _metadata
+			}, _level_initializers, _level_extraInitializers);
+			__esDecorate(this, null, _active_decorators, {
+				kind: "accessor",
+				name: "active",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "active" in obj,
+					get: (obj) => obj.active,
+					set: (obj, value) => {
+						obj.active = value;
+					}
+				},
+				metadata: _metadata
+			}, _active_initializers, _active_extraInitializers);
+			__esDecorate(this, null, _amount_decorators, {
+				kind: "accessor",
+				name: "amount",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "amount" in obj,
+					get: (obj) => obj.amount,
+					set: (obj, value) => {
+						obj.amount = value;
+					}
+				},
+				metadata: _metadata
+			}, _amount_initializers, _amount_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-tab-label";
+		}
+		static {
+			this.role = "tab";
+		}
+		static {
+			this.styles = [tabLabelCommonStyles, unsafeCSS(tab_label_default)];
+		}
+		#level_accessor_storage;
+		/**
+		* The level will correspond to the heading tag generated in the title.
+		* Use this property to generate the appropriate header tag, taking SEO into consideration.
+		*/
+		get level() {
+			return this.#level_accessor_storage;
+		}
+		set level(value) {
+			this.#level_accessor_storage = value;
+		}
+		#active_accessor_storage;
+		/** Active tab state. */
+		get active() {
+			return this.#active_accessor_storage;
+		}
+		set active(value) {
+			this.#active_accessor_storage = value;
+		}
+		#amount_accessor_storage;
+		/** Amount displayed inside the tab. */
+		get amount() {
+			return this.#amount_accessor_storage;
+		}
+		set amount(value) {
+			this.#amount_accessor_storage = value;
+		}
+		/** Get the `sbb-tab` related to the `sbb-tab-label`. */
+		get tab() {
+			return this.nextElementSibling?.localName === "sbb-tab" ? this.nextElementSibling : null;
+		}
+		/** Get the parent `sbb-tab-group`. */
+		get group() {
+			return this.closest("sbb-tab-group");
+		}
+		constructor() {
+			super();
+			/** Whether the tab is selected. */
+			this._selected = false;
+			this._previousSize = null;
+			this.#level_accessor_storage = __runInitializers(this, _level_initializers, "1");
+			this.#active_accessor_storage = (__runInitializers(this, _level_extraInitializers), __runInitializers(this, _active_initializers, false));
+			this.#amount_accessor_storage = (__runInitializers(this, _active_extraInitializers), __runInitializers(this, _amount_initializers, ""));
+			__runInitializers(this, _amount_extraInitializers);
+			this.addEventListener("click", () => this.activate());
+			this.addController(new SbbPropertyWatcherController(this, () => this.group, { size: (g) => {
+				if (this._previousSize) this.internals.states.delete(`size-${this._previousSize}`);
+				this._previousSize = g.size ?? null;
+				if (this._previousSize) this.internals.states.add(`size-${this._previousSize}`);
+			} }));
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.slot = "tab-bar";
+			this.tabIndex = this.active ? 0 : -1;
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("active")) {
+				this.internals.ariaSelected = `${this.active}`;
+				if (this.active && !this.disabled) this.activate();
+				else this.deactivate();
+			}
+			if (changedProperties.has("disabled") && this.disabled) {
+				this.tabIndex = -1;
+				if (this.active) {
+					this.deactivate();
+					this.group?.activateTab(0);
+				}
+			}
+		}
+		/** Deactivate the tab. */
+		deactivate() {
+			this.active = false;
+			this.tab?.["deactivate"]();
+			this._selected = false;
+			this.tabIndex = -1;
+		}
+		/** Select the tab, deactivating the current selected one, and dispatch the tabchange event. */
+		activate() {
+			if (this.disabled) return;
+			const tabLabels = this.group?.labels || [];
+			const prevActiveTabLabel = tabLabels.find((e) => e._selected);
+			if (prevActiveTabLabel !== this) {
+				prevActiveTabLabel?.deactivate();
+				this.active = true;
+				this.tab?.["activate"]();
+				this._selected = true;
+				this.tabIndex = 0;
+				this.tab?.dispatchEvent(new Event("active", {
+					bubbles: true,
+					composed: true
+				}));
+				const tabchange = {
+					activeIndex: tabLabels.findIndex((e) => e === this),
+					activeTabLabel: this,
+					activeTab: this.tab,
+					previousIndex: tabLabels.findIndex((e) => e === prevActiveTabLabel),
+					previousTabLabel: prevActiveTabLabel,
+					previousTab: prevActiveTabLabel?.tab
+				};
+				this.group?.dispatchEvent(new SbbTabChangeEvent(tabchange));
+			}
+		}
+		/**
+		* @internal
+		*/
+		linkToTab() {
+			if (!this.tab) return;
+			this.internals.ariaControlsElements = [this.tab];
+		}
+		render() {
+			const TAGNAME = `h${Number(this.level) < 7 ? this.level : "1"}`;
+			return html$1`
+        <${unsafeStatic(TAGNAME)} class="sbb-tab-label">
+          <span class="sbb-tab-label__icon">
+            ${this.renderIconSlot()}
+          </span>
+          <span class="sbb-tab-label__text">
+            <slot></slot>
+          </span>
+          <p class="sbb-tab-label__amount">
+            <slot name="amount">${this.amount}</slot>
+          </p>
+        </${unsafeStatic(TAGNAME)}>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbTabLabelElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tab-label.component-BbQu5sA-.js","names":[],"sources":["../../../src/elements/tabs/tab-label/tab-label.scss?inline","../../../src/elements/tabs/tab-label/tab-label.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n@use '../tabs.global' as tabs-global;\n\n:host {\n  display: inline-block;\n  max-width: 100%;\n\n  // Use !important here to not interfere with Firefox focus ring definition\n  // which appears in normalize CSS of several frameworks.\n  outline: none !important;\n}\n\n.sbb-tab-label {\n  cursor: var(--sbb-tab-label-cursor);\n  user-select: none;\n  -webkit-tap-highlight-color: transparent;\n}\n\n.sbb-tab-label__icon {\n  display: flex;\n  flex-shrink: 0;\n\n  :host(:not(:state(slotted-icon), :state(has-icon-name))) & {\n    display: none;\n  }\n}\n\n.sbb-tab-label__text {\n  @include sbb.ellipsis;\n\n  :host(:not(:state(slotted))) & {\n    display: none;\n  }\n}\n\n.sbb-tab-label__amount {\n  @include tabs-global.tab-label-amount;\n\n  :host(:not(:state(slotted-amount), [amount])) & {\n    display: none;\n  }\n}\n","import { type CSSResultGroup, type PropertyValues, type TemplateResult, unsafeCSS } from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { html, unsafeStatic } from 'lit/static-html.js';\n\nimport {\n  forceType,\n  omitEmptyConverter,\n  SbbDisabledMixin,\n  SbbElement,\n  type SbbHeadingLevel,\n  SbbPropertyWatcherController,\n} from '../../core.ts';\nimport { SbbIconNameMixin } from '../../icon.pure.ts';\nimport { tabLabelCommonStyles } from '../common/styles.ts';\nimport type { SbbTabElement } from '../tab/tab.component.ts';\nimport { SbbTabChangeEvent, type SbbTabGroupElement } from '../tab-group/tab-group.component.ts';\n\nimport style from './tab-label.scss?inline';\n\n/**\n * Combined with a `sbb-tab-group`, it displays a tab's title.\n *\n * @slot - Use the unnamed slot to add content to the tab title.\n * @slot icon - Use this slot to display an icon to the left of the title, by providing the `sbb-icon` component.\n * @slot amount - Provide a number to show an amount to the right of the title.\n */\nexport class SbbTabLabelElement extends SbbDisabledMixin(SbbIconNameMixin(SbbElement)) {\n  public static override readonly elementName: string = 'sbb-tab-label';\n  public static override role = 'tab';\n  public static override styles: CSSResultGroup = [tabLabelCommonStyles, unsafeCSS(style)];\n\n  /** Whether the tab is selected. */\n  private _selected: boolean = false;\n  private _previousSize: SbbTabGroupElement['size'] = null;\n\n  /**\n   * The level will correspond to the heading tag generated in the title.\n   * Use this property to generate the appropriate header tag, taking SEO into consideration.\n   */\n  @property() public accessor level: SbbHeadingLevel = '1';\n\n  /** Active tab state. */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor active: boolean = false;\n\n  /** Amount displayed inside the tab. */\n  @forceType()\n  @property({ reflect: true, converter: omitEmptyConverter })\n  public accessor amount: string = '';\n\n  /** Get the `sbb-tab` related to the `sbb-tab-label`. */\n  public get tab(): SbbTabElement | null {\n    return this.nextElementSibling?.localName === 'sbb-tab'\n      ? (this.nextElementSibling as SbbTabElement)\n      : null;\n  }\n\n  /** Get the parent `sbb-tab-group`. */\n  public get group(): SbbTabGroupElement | null {\n    return this.closest('sbb-tab-group');\n  }\n\n  public constructor() {\n    super();\n\n    this.addEventListener('click', () => this.activate());\n    this.addController(\n      new SbbPropertyWatcherController(this, () => this.group, {\n        size: (g) => {\n          if (this._previousSize) {\n            this.internals.states.delete(`size-${this._previousSize}`);\n          }\n          this._previousSize = g.size ?? null;\n          if (this._previousSize) {\n            this.internals.states.add(`size-${this._previousSize}`);\n          }\n        },\n      }),\n    );\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.slot = 'tab-bar';\n    this.tabIndex = this.active ? 0 : -1;\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('active')) {\n      this.internals.ariaSelected = `${this.active}`;\n\n      if (this.active && !this.disabled) {\n        this.activate();\n      } else {\n        this.deactivate();\n      }\n    }\n\n    if (changedProperties.has('disabled') && this.disabled) {\n      this.tabIndex = -1;\n      if (this.active) {\n        this.deactivate();\n        this.group?.activateTab(0);\n      }\n    }\n  }\n\n  /** Deactivate the tab. */\n  public deactivate(): void {\n    this.active = false;\n    this.tab?.['deactivate']();\n    this._selected = false;\n    this.tabIndex = -1;\n  }\n\n  /** Select the tab, deactivating the current selected one, and dispatch the tabchange event. */\n  public activate(): void {\n    if (this.disabled) {\n      if (import.meta.env.DEV) {\n        console.warn('You cannot activate a disabled tab');\n      }\n      return;\n    }\n\n    const tabLabels: SbbTabLabelElement[] = this.group?.labels || [];\n    const prevActiveTabLabel = tabLabels.find((e) => e._selected);\n    if (prevActiveTabLabel !== this) {\n      prevActiveTabLabel?.deactivate();\n      this.active = true;\n      this.tab?.['activate']();\n      this._selected = true;\n      this.tabIndex = 0;\n      this.tab?.dispatchEvent(new Event('active', { bubbles: true, composed: true }));\n      // FIXME: the name of the variable appears as event name in the readme\n      //  due to a bug in the custom-elements-manifest library.\n      //   https://github.com/open-wc/custom-elements-manifest/issues/149\n      const tabchange = {\n        activeIndex: tabLabels.findIndex((e) => e === this),\n        activeTabLabel: this,\n        activeTab: this.tab as SbbTabElement,\n        previousIndex: tabLabels.findIndex((e) => e === prevActiveTabLabel),\n        previousTabLabel: prevActiveTabLabel,\n        previousTab: prevActiveTabLabel?.tab as SbbTabElement,\n      };\n      this.group?.dispatchEvent(new SbbTabChangeEvent(tabchange));\n    }\n  }\n\n  /**\n   * @internal\n   */\n  protected linkToTab(): void {\n    if (!this.tab) {\n      if (import.meta.env.DEV) {\n        console.warn(\n          `Missing content: you should provide a related content for the tab ${this.outerHTML}.`,\n        );\n      }\n      return;\n    }\n    this.internals.ariaControlsElements = [this.tab];\n  }\n\n  protected override render(): TemplateResult {\n    const TAGNAME = `h${Number(this.level) < 7 ? this.level : '1'}`;\n\n    /* eslint-disable lit/binding-positions */\n    return html`\n        <${unsafeStatic(TAGNAME)} class=\"sbb-tab-label\">\n          <span class=\"sbb-tab-label__icon\">\n            ${this.renderIconSlot()}\n          </span>\n          <span class=\"sbb-tab-label__text\">\n            <slot></slot>\n          </span>\n          <p class=\"sbb-tab-label__amount\">\n            <slot name=\"amount\">${this.amount}</slot>\n          </p>\n        </${unsafeStatic(TAGNAME)}>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-tab-label': SbbTabLabelElement;\n  }\n}\n"],"mappings":"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"}

package/development/tab-nav-bar.component-DC4Ba7w2.js

@@ -0,0 +1,109 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement, SbbNamedSlotListMixin } from "./core.js";
+import { ResizeController } from "@lit-labs/observers/resize-controller.js";
+import { tabGroupCommonStyles, tabLabelCommonStyles } from "./tabs/common/styles.js";
+//#region src/elements/tabs/tab-nav-bar/tab-nav-bar.scss?inline
+var tab_nav_bar_default = ":host {\n  margin-block-end: var(--sbb-tab-group-content-gap);\n}";
+//#endregion
+//#region src/elements/tabs/tab-nav-bar/tab-nav-bar.component.ts
+/**
+* It displays one or more tab-label-like elements, each one is an anchor element.
+*
+* @slot - Use the unnamed slot to add anchors.
+*/
+var SbbTabNavBarElement = (() => {
+	let _classSuper = SbbNamedSlotListMixin(SbbElement);
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	return class SbbTabNavBarElement extends _classSuper {
+		constructor() {
+			super(...arguments);
+			this.listChildLocalNames = ["a"];
+			this.#size_accessor_storage = __runInitializers(this, _size_initializers, null);
+			this._resizeController = (__runInitializers(this, _size_extraInitializers), new ResizeController(this, {
+				target: null,
+				callback: () => this._onTabGroupElementResize()
+			}));
+			this._listElement = null;
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_size_decorators = [property({ reflect: true })];
+			__esDecorate(this, null, _size_decorators, {
+				kind: "accessor",
+				name: "size",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "size" in obj,
+					get: (obj) => obj.size,
+					set: (obj, value) => {
+						obj.size = value;
+					}
+				},
+				metadata: _metadata
+			}, _size_initializers, _size_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-tab-nav-bar";
+		}
+		static {
+			this.styles = [
+				tabLabelCommonStyles,
+				tabGroupCommonStyles,
+				unsafeCSS(tab_nav_bar_default)
+			];
+		}
+		static {
+			this.role = "navigation";
+		}
+		#size_accessor_storage;
+		/**
+		* Size variant, either s (lean theme default), l (standard theme default) or xl.
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		_onTabGroupElementResize() {
+			this.listChildren.forEach((anchor) => {
+				anchor.assignedSlot?.parentElement?.toggleAttribute("data-has-divider", anchor === this.listChildren[0] || anchor.offsetLeft === this.listChildren[0].offsetLeft);
+			});
+			this.style.setProperty("--sbb-tab-group-width", `${this._listElement?.clientWidth}px`);
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this._updateWidthObserver();
+			this.shadowRoot?.addEventListener("slotchange", () => this._updateWidthObserver());
+		}
+		_updateWidthObserver() {
+			const target = this.shadowRoot?.querySelector(`.${this.localName}`);
+			if (target && this._listElement !== target) {
+				if (this._listElement) this._resizeController.unobserve(this._listElement);
+				this._listElement = target;
+				this._resizeController.observe(target);
+			} else if (!target && this._listElement) {
+				this._resizeController.unobserve(this._listElement);
+				this._listElement = null;
+			}
+		}
+		render() {
+			return this.renderList();
+		}
+	};
+})();
+//#endregion
+export { SbbTabNavBarElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/{tab.component-BVhYPy5Y.js → tab.component-Bsdzs7P2.js}

@@ -65,4 +65,4 @@ var SbbTabElement = class extends SbbElement {
 //#endregion
 export { SbbTabElement as t };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/table/table-wrapper/table-wrapper.component.js

@@ -1,2 +1,2 @@
-import { t as SbbTableWrapperElement } from "../../table-wrapper.component-By59zmcU.js";
+import { t as SbbTableWrapperElement } from "../../table-wrapper.component-Cqc9PHZl.js";
 export { SbbTableWrapperElement };

package/development/{table-wrapper.component-By59zmcU.js → table-wrapper.component-Cqc9PHZl.js}

@@ -116,4 +116,4 @@ var SbbTableWrapperElement = (() => {
 //#endregion
 export { SbbTableWrapperElement as t };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"table-wrapper.component-By59zmcU.js","names":[],"sources":["../../../src/elements/table/table-wrapper/table-wrapper.scss?inline","../../../src/elements/table/table-wrapper/table-wrapper.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  display: block;\n  overflow: auto;\n\n  @include sbb.scrollbar-variables--size-thick;\n  @include sbb.scrollbar-variables--color-positive-track-visible;\n}\n\n:host(:focus-visible) {\n  @include sbb.focus-outline;\n}\n\n::slotted(.sbb-table) {\n  width: 100%;\n}\n\n:host([negative]) {\n  @include sbb.scrollbar-variables--color-negative-track-visible;\n}\n","import { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  isServer,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType, hostScrollbarStyles, SbbElement, SbbNegativeMixin } from '../../core.ts';\n\nimport style from './table-wrapper.scss?inline';\n\n/**\n * Wraps a table to enhance its functionality.\n *\n * @slot - Use the unnamed slot to add the table.\n */\nexport class SbbTableWrapperElement extends SbbNegativeMixin(SbbElement) {\n  public static override readonly elementName: string = 'sbb-table-wrapper';\n  public static override readonly role = 'section';\n  public static override styles: CSSResultGroup = [hostScrollbarStyles, unsafeCSS(style)];\n\n  /** Whether the table wrapper is focusable. */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor focusable: boolean = false;\n\n  public constructor() {\n    super();\n    this.addController(\n      new ResizeController(this, {\n        skipInitial: true,\n        callback: () => this._checkHorizontalScrollbarOffset(),\n      }),\n    );\n\n    this.addEventListener?.('scroll', () => this._checkHorizontalScrollbarOffset(), {\n      passive: true,\n    });\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    // When including the scrollbar styles on the host, there is no hover effect of the scrollbar possible.\n    // In most cases, the component will be used in Light DOM. To also support the hover effect,\n    // we additionally add the scrollbar CSS classes to the host.\n    // This is an exception as we normally don't alter the classList of the host.\n    this._updateScrollbarClass();\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('focusable')) {\n      if (this.focusable) {\n        if (!this.hasAttribute('tabindex')) {\n          this.setAttribute('tabindex', '0');\n        }\n      } else {\n        this.removeAttribute('tabindex');\n      }\n    }\n\n    if (changedProperties.has('negative')) {\n      this._updateScrollbarClass();\n    }\n  }\n\n  private _updateScrollbarClass(): void {\n    if (isServer) {\n      return;\n    }\n    if (this.negative) {\n      this.classList.remove('sbb-scrollbar-thick-track-visible');\n      this.classList.add('sbb-scrollbar-thick-negative-track-visible');\n    } else {\n      this.classList.remove('sbb-scrollbar-thick-negative-track-visible');\n      this.classList.add('sbb-scrollbar-thick-track-visible');\n    }\n  }\n\n  /**\n   *  Calculates whether the table is horizontally scrolled and adds the\n   *  corresponding class `sbb-table-wrapper-offset-${none | left | right | both}`\n   */\n  private _checkHorizontalScrollbarOffset(): void {\n    const state = this._calculateScrollOffset();\n    this.classList.remove(\n      `sbb-table-wrapper-offset-none`,\n      `sbb-table-wrapper-offset-left`,\n      `sbb-table-wrapper-offset-right`,\n      `sbb-table-wrapper-offset-both`,\n    );\n    this.classList.add(`sbb-table-wrapper-offset-${state}`);\n  }\n\n  private _calculateScrollOffset(): 'none' | 'left' | 'right' | 'both' {\n    if (this.scrollWidth === this.offsetWidth) {\n      return 'none';\n    }\n    const isAtStart = this.scrollLeft === 0;\n    // In some cases the combined value of scrollLeft and offsetWidth is off by\n    // 1 pixel from the scrollWidth.\n    const isAtEnd = this.scrollWidth - this.scrollLeft - this.offsetWidth <= 1;\n\n    if (isAtStart) {\n      return isAtEnd ? 'none' : 'right';\n    }\n    return isAtEnd ? 'left' : 'both';\n  }\n\n  protected override render(): TemplateResult {\n    return html`<slot></slot>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-table-wrapper': SbbTableWrapperElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;ICoBa,gCAAsB;mBAAS,iBAAiB,WAAW;;;;cAA3D,+BAA+B,YAA4B;;;4BAMrE,WAAW,EACX,SAAS;IAAE,SAAS;IAAM,MAAM;IAAS,CAAC,CAAA;GAC3C,aAAA,MAAA,MAAA,uBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,eAAA;KAAA,MAAA,QAAA,IAAgB;KAAS,MAAA,KAAA,UAAA;MAAA,IAAT,YAAS;;KAAA;IAAA,UAAA;IAAA,EAAA,yBAAA,6BAAA;;;;;;;;;GAPO,KAAA,cAAsB;;;GACtB,KAAA,OAAO;;;GAChB,KAAA,SAAyB,CAAC,qBAAqB,UAAU,sBAAM,CAAC;;EAKvF,8BAAA,kBAAA,MAAA,yBAAqC,MAAK;;EAA1C,IAAgB,YAAS;GAAA,OAAA,KAAA;;EAAzB,IAAgB,UAAS,OAAA;GAAA,KAAA,8BAAA;;EAEzB,cAAA;GACE,OAAO;;GACP,KAAK,cACH,IAAI,iBAAiB,MAAM;IACzB,aAAa;IACb,gBAAgB,KAAK,iCAAA;IACtB,CAAC,CACH;GAED,KAAK,mBAAmB,gBAAgB,KAAK,iCAAiC,EAAE,EAC9E,SAAS,MACV,CAAC;;EAGY,oBAAiB;GAC/B,MAAM,mBAAmB;GAMzB,KAAK,uBAAuB;;EAGX,WAAW,mBAAuC;GACnE,MAAM,WAAW,kBAAkB;GAEnC,IAAI,kBAAkB,IAAI,YAAY,EACpC,IAAI,KAAK;QACH,CAAC,KAAK,aAAa,WAAW,EAChC,KAAK,aAAa,YAAY,IAAI;UAGpC,KAAK,gBAAgB,WAAW;GAIpC,IAAI,kBAAkB,IAAI,WAAW,EACnC,KAAK,uBAAuB;;EAIxB,wBAAqB;GAC3B,IAAI,UACF;GAEF,IAAI,KAAK,UAAU;IACjB,KAAK,UAAU,OAAO,oCAAoC;IAC1D,KAAK,UAAU,IAAI,6CAA6C;UAC3D;IACL,KAAK,UAAU,OAAO,6CAA6C;IACnE,KAAK,UAAU,IAAI,oCAAoC;;;;;;;EAQnD,kCAA+B;GACrC,MAAM,QAAQ,KAAK,wBAAwB;GAC3C,KAAK,UAAU,OACb,iCACA,iCACA,kCACA,gCACD;GACD,KAAK,UAAU,IAAI,4BAA4B,QAAQ;;EAGjD,yBAAsB;GAC5B,IAAI,KAAK,gBAAgB,KAAK,aAC5B,OAAO;GAET,MAAM,YAAY,KAAK,eAAe;GAGtC,MAAM,UAAU,KAAK,cAAc,KAAK,aAAa,KAAK,eAAe;GAEzE,IAAI,WACF,OAAO,UAAU,SAAS;GAE5B,OAAO,UAAU,SAAS;;EAGT,SAAM;GACvB,OAAO,IAAI"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"table-wrapper.component-Cqc9PHZl.js","names":[],"sources":["../../../src/elements/table/table-wrapper/table-wrapper.scss?inline","../../../src/elements/table/table-wrapper/table-wrapper.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  display: block;\n  overflow: auto;\n\n  @include sbb.scrollbar-variables--size-thick;\n  @include sbb.scrollbar-variables--color-positive-track-visible;\n}\n\n:host(:focus-visible) {\n  @include sbb.focus-outline;\n}\n\n::slotted(.sbb-table) {\n  width: 100%;\n}\n\n:host([negative]) {\n  @include sbb.scrollbar-variables--color-negative-track-visible;\n}\n","import { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  isServer,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType, hostScrollbarStyles, SbbElement, SbbNegativeMixin } from '../../core.ts';\n\nimport style from './table-wrapper.scss?inline';\n\n/**\n * Wraps a table to enhance its functionality.\n *\n * @slot - Use the unnamed slot to add the table.\n */\nexport class SbbTableWrapperElement extends SbbNegativeMixin(SbbElement) {\n  public static override readonly elementName: string = 'sbb-table-wrapper';\n  public static override readonly role = 'section';\n  public static override styles: CSSResultGroup = [hostScrollbarStyles, unsafeCSS(style)];\n\n  /** Whether the table wrapper is focusable. */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor focusable: boolean = false;\n\n  public constructor() {\n    super();\n    this.addController(\n      new ResizeController(this, {\n        skipInitial: true,\n        callback: () => this._checkHorizontalScrollbarOffset(),\n      }),\n    );\n\n    this.addEventListener?.('scroll', () => this._checkHorizontalScrollbarOffset(), {\n      passive: true,\n    });\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    // When including the scrollbar styles on the host, there is no hover effect of the scrollbar possible.\n    // In most cases, the component will be used in Light DOM. To also support the hover effect,\n    // we additionally add the scrollbar CSS classes to the host.\n    // This is an exception as we normally don't alter the classList of the host.\n    this._updateScrollbarClass();\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('focusable')) {\n      if (this.focusable) {\n        if (!this.hasAttribute('tabindex')) {\n          this.setAttribute('tabindex', '0');\n        }\n      } else {\n        this.removeAttribute('tabindex');\n      }\n    }\n\n    if (changedProperties.has('negative')) {\n      this._updateScrollbarClass();\n    }\n  }\n\n  private _updateScrollbarClass(): void {\n    if (isServer) {\n      return;\n    }\n    if (this.negative) {\n      this.classList.remove('sbb-scrollbar-thick-track-visible');\n      this.classList.add('sbb-scrollbar-thick-negative-track-visible');\n    } else {\n      this.classList.remove('sbb-scrollbar-thick-negative-track-visible');\n      this.classList.add('sbb-scrollbar-thick-track-visible');\n    }\n  }\n\n  /**\n   *  Calculates whether the table is horizontally scrolled and adds the\n   *  corresponding class `sbb-table-wrapper-offset-${none | left | right | both}`\n   */\n  private _checkHorizontalScrollbarOffset(): void {\n    const state = this._calculateScrollOffset();\n    this.classList.remove(\n      `sbb-table-wrapper-offset-none`,\n      `sbb-table-wrapper-offset-left`,\n      `sbb-table-wrapper-offset-right`,\n      `sbb-table-wrapper-offset-both`,\n    );\n    this.classList.add(`sbb-table-wrapper-offset-${state}`);\n  }\n\n  private _calculateScrollOffset(): 'none' | 'left' | 'right' | 'both' {\n    if (this.scrollWidth === this.offsetWidth) {\n      return 'none';\n    }\n    const isAtStart = this.scrollLeft === 0;\n    // In some cases the combined value of scrollLeft and offsetWidth is off by\n    // 1 pixel from the scrollWidth.\n    const isAtEnd = this.scrollWidth - this.scrollLeft - this.offsetWidth <= 1;\n\n    if (isAtStart) {\n      return isAtEnd ? 'none' : 'right';\n    }\n    return isAtEnd ? 'left' : 'both';\n  }\n\n  protected override render(): TemplateResult {\n    return html`<slot></slot>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-table-wrapper': SbbTableWrapperElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;ICoBa,gCAAsB;mBAAS,iBAAiB,UAAU;;;;cAA1D,+BAA+B,YAA4B;;;4BAMrE,UAAS,GACT,SAAS;IAAE,SAAS;IAAM,MAAM;GAAO,CAAE,CAAC;GAC3C,aAAA,MAAA,MAAA,uBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,eAAA;KAAA,MAAA,QAAA,IAAgB;KAAS,MAAA,KAAA,UAAA;MAAA,IAAT,YAAS;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,yBAAA,4BAAA;;;;;;;;;GAPO,KAAA,cAAsB;EAAoB;;GAC1C,KAAA,OAAO;EAAU;;GAC1B,KAAA,SAAyB,CAAC,qBAAqB,UAAU,qBAAK,CAAC;EAAE;EAKxF,8BAAA,kBAAA,MAAA,yBAAqC,KAAK;;EAA1C,IAAgB,YAAS;GAAA,OAAA,KAAA;EAAA;EAAzB,IAAgB,UAAS,OAAA;GAAA,KAAA,8BAAA;EAAA;EAEzB,cAAA;GACE,MAAK;;GACL,KAAK,cACH,IAAI,iBAAiB,MAAM;IACzB,aAAa;IACb,gBAAgB,KAAK,gCAA+B;IACrD,CAAC;GAGJ,KAAK,mBAAmB,gBAAgB,KAAK,gCAA+B,GAAI,EAC9E,SAAS,KAAA,CACV;;EAGa,oBAAiB;GAC/B,MAAM,kBAAiB;GAMvB,KAAK,sBAAqB;EAC5B;EAEmB,WAAW,mBAAuC;GACnE,MAAM,WAAW,iBAAiB;GAElC,IAAI,kBAAkB,IAAI,WAAW,GACnC,IAAI,KAAK;QACH,CAAC,KAAK,aAAa,UAAU,GAC/B,KAAK,aAAa,YAAY,GAAG;GAAA,OAGnC,KAAK,gBAAgB,UAAU;GAInC,IAAI,kBAAkB,IAAI,UAAU,GAClC,KAAK,sBAAqB;EAE9B;EAEQ,wBAAqB;GAC3B,IAAI,UACF;GAEF,IAAI,KAAK,UAAU;IACjB,KAAK,UAAU,OAAO,mCAAmC;IACzD,KAAK,UAAU,IAAI,4CAA4C;GACjE,OAAO;IACL,KAAK,UAAU,OAAO,4CAA4C;IAClE,KAAK,UAAU,IAAI,mCAAmC;GACxD;EACF;;;;;EAMQ,kCAA+B;GACrC,MAAM,QAAQ,KAAK,uBAAsB;GACzC,KAAK,UAAU,OACb,iCACA,iCACA,kCACA,+BAA+B;GAEjC,KAAK,UAAU,IAAI,4BAA4B,OAAO;EACxD;EAEQ,yBAAsB;GAC5B,IAAI,KAAK,gBAAgB,KAAK,aAC5B,OAAO;GAET,MAAM,YAAY,KAAK,eAAe;GAGtC,MAAM,UAAU,KAAK,cAAc,KAAK,aAAa,KAAK,eAAe;GAEzE,IAAI,WACF,OAAO,UAAU,SAAS;GAE5B,OAAO,UAAU,SAAS;EAC5B;EAEmB,SAAM;GACvB,OAAO,IAAI;EACb"}

package/development/table.js

@@ -1,4 +1,4 @@
-import { t as SbbTableWrapperElement } from "./table-wrapper.component-By59zmcU.js";
+import { t as SbbTableWrapperElement } from "./table-wrapper.component-Cqc9PHZl.js";
 import "./table.pure.js";
 //#region src/elements/table.ts
 /** @entrypoint */
@@ -6,4 +6,4 @@ SbbTableWrapperElement.define();
 //#endregion
 export { SbbTableWrapperElement };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VsZW1lbnRzL3RhYmxlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHsgU2JiVGFibGVXcmFwcGVyRWxlbWVudCB9IGZyb20gJy4vdGFibGUucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vdGFibGUucHVyZS50cyc7XG5cblNiYlRhYmxlV3JhcHBlckVsZW1lbnQuZGVmaW5lKCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFLQSx1QkFBdUIsUUFBUSJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VsZW1lbnRzL3RhYmxlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHsgU2JiVGFibGVXcmFwcGVyRWxlbWVudCB9IGZyb20gJy4vdGFibGUucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vdGFibGUucHVyZS50cyc7XG5cblNiYlRhYmxlV3JhcHBlckVsZW1lbnQuZGVmaW5lKCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFLQSx1QkFBdUIsT0FBTSJ9

package/development/table.pure.js

@@ -1,2 +1,2 @@
-import { t as SbbTableWrapperElement } from "./table-wrapper.component-By59zmcU.js";
+import { t as SbbTableWrapperElement } from "./table-wrapper.component-Cqc9PHZl.js";
 export { SbbTableWrapperElement };

package/development/tabs/common/styles.js

@@ -1,2 +1,2 @@
-import { n as tabLabelCommonStyles, t as tabGroupCommonStyles } from "../../styles-WppEBrlW.js";
+import { n as tabLabelCommonStyles, t as tabGroupCommonStyles } from "../../styles-BTV2MyrZ.js";
 export { tabGroupCommonStyles, tabLabelCommonStyles };

package/development/tabs/tab/tab.component.js

@@ -1,2 +1,2 @@
-import { t as SbbTabElement } from "../../tab.component-BVhYPy5Y.js";
+import { t as SbbTabElement } from "../../tab.component-Bsdzs7P2.js";
 export { SbbTabElement };

package/development/tabs/tab-group/tab-group.component.d.ts

@@ -2,19 +2,26 @@ import { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
 import { SbbElement } from '../../core.ts';
 import { SbbTabElement } from '../tab/tab.component.ts';
 import { SbbTabLabelElement } from '../tab-label/tab-label.component.ts';
-export interface SbbTabChangedEventDetails {
-    activeIndex: number;
-    activeTabLabel: SbbTabLabelElement;
-    activeTab: SbbTabElement;
-    previousIndex: number;
-    previousTabLabel: SbbTabLabelElement | undefined;
-    previousTab: SbbTabElement | undefined;
+export declare class SbbTabChangeEvent extends Event {
+    private readonly _activeIndex;
+    private readonly _activeTabLabel;
+    private readonly _activeTab;
+    private readonly _previousIndex;
+    private readonly _previousTabLabel;
+    private readonly _previousTab;
+    get activeIndex(): number;
+    get activeTabLabel(): SbbTabLabelElement;
+    get activeTab(): SbbTabElement;
+    get previousIndex(): number;
+    get previousTabLabel(): SbbTabLabelElement | undefined;
+    get previousTab(): SbbTabElement | undefined;
+    constructor({ activeIndex, activeTabLabel, activeTab, previousIndex, previousTabLabel, previousTab, }: Omit<SbbTabChangeEvent, keyof Event>);
 }
 /**
  * It displays one or more tabs, each one with a label and some content.
  *
  * @slot - Use the unnamed slot to add content to the `sbb-tab-group` via `sbb-tab-label` and `sbb-tab` instances.
- * @event {CustomEvent<SbbTabChangedEventDetails>} tabchange - The tabchange event is dispatched when a tab is selected.
+ * @event {SbbTabChangeEvent} tabchange - The tabchange event is dispatched when a tab is selected.
  */
 export declare class SbbTabGroupElement extends SbbElement {
     static readonly elementName: string;

package/development/tabs/tab-group/tab-group.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tab-group.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/tabs/tab-group/tab-group.component.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,cAAc,EAEnB,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAIb,OAAO,EAIL,UAAU,EAEX,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAI9E,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,kBAAkB,CAAC;IACnC,SAAS,EAAE,aAAa,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACjD,WAAW,EAAE,aAAa,GAAG,SAAS,CAAC;CACxC;AAED;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,UAAU;IAChD,gBAAgC,WAAW,EAAE,MAAM,CAAmB;IACtE,OAAuB,MAAM,EAAE,cAAc,CAA4C;IACzF,gBAAuB,MAAM;;MAElB;IAEX,OAAO,CAAC,gBAAgB,CAAe;IACvC,OAAO,CAAC,uBAAuB,CAI5B;IACH,OAAO,CAAC,4BAA4B,CAAC,CAAgC;IAErE;;OAEG;IACH,SACgB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,CAAQ;IAErD;;;OAGG;IACH,SAEgB,oBAAoB,EAAE,MAAM,CAAK;IAEjD;;;;OAIG;IACH,SAEgB,WAAW,EAAE,OAAO,CAAS;IAE7C,yCAAyC;IACzC,IAAW,MAAM,IAAI,kBAAkB,EAAE,CAQxC;IAED,mCAAmC;IACnC,IAAW,IAAI,IAAI,aAAa,EAAE,CAQjC;;cAOkB,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAW9E;;;OAGG;IACI,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMtC;;;OAGG;IACI,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMrC;;;OAGG;IACI,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIvC,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,cAAc;IAoBtB;;OAEG;IACH,SAAS,CAAC,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;cAIvC,MAAM,IAAI,cAAc;CAkB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,eAAe,EAAE,kBAAkB,CAAC;KACrC;CACF"}
+{"version":3,"file":"tab-group.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/tabs/tab-group/tab-group.component.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,cAAc,EAEnB,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAIb,OAAO,EAIL,UAAU,EAEX,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAI9E,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqB;IACrD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAiC;IACnE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4B;IAEzD,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,IAAW,cAAc,IAAI,kBAAkB,CAE9C;IAED,IAAW,SAAS,IAAI,aAAa,CAEpC;IAED,IAAW,aAAa,IAAI,MAAM,CAEjC;IAED,IAAW,gBAAgB,IAAI,kBAAkB,GAAG,SAAS,CAE5D;IAED,IAAW,WAAW,IAAI,aAAa,GAAG,SAAS,CAElD;gBAEkB,EACjB,WAAW,EACX,cAAc,EACd,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,WAAW,GACZ,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,KAAK,CAAC;CASxC;AAED;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,UAAU;IAChD,gBAAgC,WAAW,EAAE,MAAM,CAAmB;IACtE,OAAuB,MAAM,EAAE,cAAc,CAA4C;IACzF,gBAAuB,MAAM;;MAElB;IAEX,OAAO,CAAC,gBAAgB,CAAe;IACvC,OAAO,CAAC,uBAAuB,CAI5B;IACH,OAAO,CAAC,4BAA4B,CAAC,CAAgC;IAErE;;OAEG;IACH,SACgB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,CAAQ;IAErD;;;OAGG;IACH,SAEgB,oBAAoB,EAAE,MAAM,CAAK;IAEjD;;;;OAIG;IACH,SAEgB,WAAW,EAAE,OAAO,CAAS;IAE7C,yCAAyC;IACzC,IAAW,MAAM,IAAI,kBAAkB,EAAE,CAQxC;IAED,mCAAmC;IACnC,IAAW,IAAI,IAAI,aAAa,EAAE,CAQjC;;cAOkB,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAW9E;;;OAGG;IACI,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMtC;;;OAGG;IACI,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMrC;;;OAGG;IACI,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIvC,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,cAAc;IAoBtB;;OAEG;IACH,SAAS,CAAC,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;cAIvC,MAAM,IAAI,cAAc;CAkB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,eAAe,EAAE,kBAAkB,CAAC;KACrC;CACF"}

package/development/tabs/tab-group/tab-group.component.js

@@ -1,2 +1,2 @@
-import { t as SbbTabGroupElement } from "../../tab-group.component-D4fvd6Uu.js";
-export { SbbTabGroupElement };
+import { n as SbbTabGroupElement, t as SbbTabChangeEvent } from "../../tab-group.component-DBg6I8W7.js";
+export { SbbTabChangeEvent, SbbTabGroupElement };

package/development/tabs/tab-label/tab-label.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tab-label.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/tabs/tab-label/tab-label.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAa,MAAM,KAAK,CAAC;AAI/F,OAAO,EAIL,UAAU,EACV,KAAK,eAAe,EAErB,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAEV,kBAAkB,EACnB,MAAM,qCAAqC,CAAC;;AAI7C;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,uBAA8C;IACpF,gBAAgC,WAAW,EAAE,MAAM,CAAmB;IACtE,OAAuB,IAAI,SAAS;IACpC,OAAuB,MAAM,EAAE,cAAc,CAA4C;IAEzF,mCAAmC;IACnC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,aAAa,CAAoC;IAEzD;;;OAGG;IACH,SAA4B,KAAK,EAAE,eAAe,CAAO;IAEzD,wBAAwB;IACxB,SAEgB,MAAM,EAAE,OAAO,CAAS;IAExC,uCAAuC;IACvC,SAEgB,MAAM,EAAE,MAAM,CAAM;IAEpC,wDAAwD;IACxD,IAAW,GAAG,IAAI,aAAa,GAAG,IAAI,CAIrC;IAED,sCAAsC;IACtC,IAAW,KAAK,IAAI,kBAAkB,GAAG,IAAI,CAE5C;;IAqBe,iBAAiB,IAAI,IAAI;cAMtB,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAsB5E,0BAA0B;IACnB,UAAU,IAAI,IAAI;IAOzB,+FAA+F;IACxF,QAAQ,IAAI,IAAI;IAkCvB;;OAEG;IACH,SAAS,CAAC,SAAS,IAAI,IAAI;cAYR,MAAM,IAAI,cAAc;CAkB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,eAAe,EAAE,kBAAkB,CAAC;KACrC;CACF"}
+{"version":3,"file":"tab-label.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/tabs/tab-label/tab-label.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAa,MAAM,KAAK,CAAC;AAI/F,OAAO,EAIL,UAAU,EACV,KAAK,eAAe,EAErB,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAqB,KAAK,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;;AAIjG;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,uBAA8C;IACpF,gBAAgC,WAAW,EAAE,MAAM,CAAmB;IACtE,OAAuB,IAAI,SAAS;IACpC,OAAuB,MAAM,EAAE,cAAc,CAA4C;IAEzF,mCAAmC;IACnC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,aAAa,CAAoC;IAEzD;;;OAGG;IACH,SAA4B,KAAK,EAAE,eAAe,CAAO;IAEzD,wBAAwB;IACxB,SAEgB,MAAM,EAAE,OAAO,CAAS;IAExC,uCAAuC;IACvC,SAEgB,MAAM,EAAE,MAAM,CAAM;IAEpC,wDAAwD;IACxD,IAAW,GAAG,IAAI,aAAa,GAAG,IAAI,CAIrC;IAED,sCAAsC;IACtC,IAAW,KAAK,IAAI,kBAAkB,GAAG,IAAI,CAE5C;;IAqBe,iBAAiB,IAAI,IAAI;cAMtB,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAsB5E,0BAA0B;IACnB,UAAU,IAAI,IAAI;IAOzB,+FAA+F;IACxF,QAAQ,IAAI,IAAI;IAgCvB;;OAEG;IACH,SAAS,CAAC,SAAS,IAAI,IAAI;cAYR,MAAM,IAAI,cAAc;CAkB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,eAAe,EAAE,kBAAkB,CAAC;KACrC;CACF"}

package/development/tabs/tab-label/tab-label.component.js

@@ -1,2 +1,2 @@
-import { t as SbbTabLabelElement } from "../../tab-label.component-CNX8bsJL.js";
+import { t as SbbTabLabelElement } from "../../tab-label.component-BbQu5sA-.js";
 export { SbbTabLabelElement };

package/development/tabs/tab-nav-bar/tab-nav-bar.component.js

@@ -1,2 +1,2 @@
-import { t as SbbTabNavBarElement } from "../../tab-nav-bar.component-B_mi8GGR.js";
+import { t as SbbTabNavBarElement } from "../../tab-nav-bar.component-DC4Ba7w2.js";
 export { SbbTabNavBarElement };

package/development/tabs.js

@@ -1,8 +1,8 @@
-import { t as SbbTabGroupElement } from "./tab-group.component-D4fvd6Uu.js";
-import { t as SbbTabLabelElement } from "./tab-label.component-CNX8bsJL.js";
-import { t as SbbTabNavBarElement } from "./tab-nav-bar.component-B_mi8GGR.js";
-import { t as SbbTabElement } from "./tab.component-BVhYPy5Y.js";
-import { n as tabLabelCommonStyles, t as tabGroupCommonStyles } from "./styles-WppEBrlW.js";
+import { n as SbbTabGroupElement, t as SbbTabChangeEvent } from "./tab-group.component-DBg6I8W7.js";
+import { t as SbbTabLabelElement } from "./tab-label.component-BbQu5sA-.js";
+import { t as SbbTabNavBarElement } from "./tab-nav-bar.component-DC4Ba7w2.js";
+import { t as SbbTabElement } from "./tab.component-Bsdzs7P2.js";
+import { n as tabLabelCommonStyles, t as tabGroupCommonStyles } from "./styles-BTV2MyrZ.js";
 import "./tabs.pure.js";
 //#region src/elements/tabs.ts
 /** @entrypoint */
@@ -11,6 +11,6 @@ SbbTabGroupElement.define();
 SbbTabLabelElement.define();
 SbbTabNavBarElement.define();
 //#endregion
-export { SbbTabElement, SbbTabGroupElement, SbbTabLabelElement, SbbTabNavBarElement, tabGroupCommonStyles, tabLabelCommonStyles };
+export { SbbTabChangeEvent, SbbTabElement, SbbTabGroupElement, SbbTabLabelElement, SbbTabNavBarElement, tabGroupCommonStyles, tabLabelCommonStyles };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFicy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvdGFicy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7XG4gIFNiYlRhYkVsZW1lbnQsXG4gIFNiYlRhYkdyb3VwRWxlbWVudCxcbiAgU2JiVGFiTGFiZWxFbGVtZW50LFxuICBTYmJUYWJOYXZCYXJFbGVtZW50LFxufSBmcm9tICcuL3RhYnMucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vdGFicy5wdXJlLnRzJztcblxuU2JiVGFiRWxlbWVudC5kZWZpbmUoKTtcblNiYlRhYkdyb3VwRWxlbWVudC5kZWZpbmUoKTtcblNiYlRhYkxhYmVsRWxlbWVudC5kZWZpbmUoKTtcblNiYlRhYk5hdkJhckVsZW1lbnQuZGVmaW5lKCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O0FBVUEsY0FBYyxRQUFRO0FBQ3RCLG1CQUFtQixRQUFRO0FBQzNCLG1CQUFtQixRQUFRO0FBQzNCLG9CQUFvQixRQUFRIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFicy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvdGFicy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7XG4gIFNiYlRhYkVsZW1lbnQsXG4gIFNiYlRhYkdyb3VwRWxlbWVudCxcbiAgU2JiVGFiTGFiZWxFbGVtZW50LFxuICBTYmJUYWJOYXZCYXJFbGVtZW50LFxufSBmcm9tICcuL3RhYnMucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vdGFicy5wdXJlLnRzJztcblxuU2JiVGFiRWxlbWVudC5kZWZpbmUoKTtcblNiYlRhYkdyb3VwRWxlbWVudC5kZWZpbmUoKTtcblNiYlRhYkxhYmVsRWxlbWVudC5kZWZpbmUoKTtcblNiYlRhYk5hdkJhckVsZW1lbnQuZGVmaW5lKCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O0FBVUEsY0FBYyxPQUFNO0FBQ3BCLG1CQUFtQixPQUFNO0FBQ3pCLG1CQUFtQixPQUFNO0FBQ3pCLG9CQUFvQixPQUFNIn0=

package/development/tabs.pure.js

@@ -1,6 +1,6 @@
-import { t as SbbTabGroupElement } from "./tab-group.component-D4fvd6Uu.js";
-import { t as SbbTabLabelElement } from "./tab-label.component-CNX8bsJL.js";
-import { t as SbbTabNavBarElement } from "./tab-nav-bar.component-B_mi8GGR.js";
-import { t as SbbTabElement } from "./tab.component-BVhYPy5Y.js";
-import { n as tabLabelCommonStyles, t as tabGroupCommonStyles } from "./styles-WppEBrlW.js";
-export { SbbTabElement, SbbTabGroupElement, SbbTabLabelElement, SbbTabNavBarElement, tabGroupCommonStyles, tabLabelCommonStyles };
+import { n as SbbTabGroupElement, t as SbbTabChangeEvent } from "./tab-group.component-DBg6I8W7.js";
+import { t as SbbTabLabelElement } from "./tab-label.component-BbQu5sA-.js";
+import { t as SbbTabNavBarElement } from "./tab-nav-bar.component-DC4Ba7w2.js";
+import { t as SbbTabElement } from "./tab.component-Bsdzs7P2.js";
+import { n as tabLabelCommonStyles, t as tabGroupCommonStyles } from "./styles-BTV2MyrZ.js";
+export { SbbTabChangeEvent, SbbTabElement, SbbTabGroupElement, SbbTabLabelElement, SbbTabNavBarElement, tabGroupCommonStyles, tabLabelCommonStyles };

package/development/tag/tag/tag.component.d.ts

@@ -30,6 +30,7 @@ export declare class SbbTagElement<T = string> extends SbbTagElement_base {
     accessor size: 's' | 'm' | null;
     constructor();
     private _tagGroup;
+    private _updateAriaRole;
     protected isDisabledExternally(): boolean;
     /** Method triggered on button click. Inverts the checked value and emits events. */
     private _handleClick;

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

@@ -1 +1 @@
-{"version":3,"file":"tag.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/tag/tag/tag.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAEnB,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAGb,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAErB,wBAAwB,EAGzB,MAAM,eAAe,CAAC;;AAMvB;;;;;;;GAOG;AACH,qBAAa,aAAa,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,kBAE9C;IACC,gBAAgC,WAAW,EAAE,MAAM,CAAa;IAChE,OAAuB,MAAM,EAAE,cAAc,CAAsB;IACnE,gBAAuB,MAAM;;;;MAIlB;IAEX,iCAAiC;IACjC,SACgB,KAAK,EAAE,CAAC,GAAG,IAAI,CAAQ;IAEvC,uCAAuC;IACvC,SAEgB,MAAM,EAAE,MAAM,CAAM;IAEpC,kCAAkC;IAClC,SAEgB,OAAO,EAAE,OAAO,CAAS;IAEzC;;;OAGG;IACH,SACgB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAQ;;IAc9C,OAAO,CAAC,SAAS;cAIE,oBAAoB,IAAI,OAAO;IAIlD,oFAAoF;IACpF,OAAO,CAAC,YAAY;cAkCD,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAe5E;;OAEG;IACa,iBAAiB,IAAI,IAAI;IAIzC;;OAEG;IACa,wBAAwB,CACtC,KAAK,EAAE,gBAAgB,GAAG,IAAI,EAC9B,OAAO,EAAE,iBAAiB,GACzB,IAAI;cAMY,eAAe,IAAI,IAAI;cAQvB,SAAS,IAAI,gBAAgB;cAI7B,cAAc,IAAI,cAAc;CAWpD;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,SAAS,EAAE,aAAa,CAAC;KAC1B;CACF"}
+{"version":3,"file":"tag.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/tag/tag/tag.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAEnB,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAGb,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAErB,wBAAwB,EAGzB,MAAM,eAAe,CAAC;;AAMvB;;;;;;;GAOG;AACH,qBAAa,aAAa,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,kBAE9C;IACC,gBAAgC,WAAW,EAAE,MAAM,CAAa;IAChE,OAAuB,MAAM,EAAE,cAAc,CAAsB;IACnE,gBAAuB,MAAM;;;;MAIlB;IAEX,iCAAiC;IACjC,SACgB,KAAK,EAAE,CAAC,GAAG,IAAI,CAAQ;IAEvC,uCAAuC;IACvC,SAEgB,MAAM,EAAE,MAAM,CAAM;IAEpC,kCAAkC;IAClC,SAEgB,OAAO,EAAE,OAAO,CAAS;IAEzC;;;OAGG;IACH,SACgB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAQ;;IAe9C,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,eAAe;cAaJ,oBAAoB,IAAI,OAAO;IAIlD,oFAAoF;IACpF,OAAO,CAAC,YAAY;cAgCD,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAsB5E;;OAEG;IACa,iBAAiB,IAAI,IAAI;IAIzC;;OAEG;IACa,wBAAwB,CACtC,KAAK,EAAE,gBAAgB,GAAG,IAAI,EAC9B,OAAO,EAAE,iBAAiB,GACzB,IAAI;cAMY,eAAe,IAAI,IAAI;cAQvB,SAAS,IAAI,gBAAgB;cAI7B,cAAc,IAAI,cAAc;CAWpD;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,SAAS,EAAE,aAAa,CAAC;KAC1B;CACF"}

package/development/tag/tag/tag.component.js

@@ -1,2 +1,2 @@
-import { t as SbbTagElement } from "../../tag.component-DG1uxD28.js";
+import { t as SbbTagElement } from "../../tag.component-CDDb2fnV.js";
 export { SbbTagElement };