@sbb-esta/lyne-elements 4.7.0 → 4.8.1

package/development/styles-TKvcDQkA.js

@@ -0,0 +1,173 @@
+import { css } from "lit";
+//#region src/elements/tabs/common/tab-group-common.scss?lit&inline
+var tab_group_common_default = css`:host {
+  display: flex;
+  flex-direction: column;
+}
+
+:host(:not([size])) {
+  --sbb-tab-group-content-gap: var(--sbb-tab-group-content-gap-default);
+}
+
+:host([size=s]) {
+  --sbb-tab-group-content-gap: var(--sbb-tab-group-content-gap-size-s);
+}
+
+:host([size=l]) {
+  --sbb-tab-group-content-gap: var(--sbb-tab-group-content-gap-size-l);
+}
+
+:host([size=xl]) {
+  --sbb-tab-group-content-gap: var(--sbb-tab-group-content-gap-size-xl);
+}
+
+.sbb-tab-group,
+.sbb-tab-nav-bar {
+  display: flex;
+  flex-wrap: wrap;
+}`;
+//#endregion
+//#region src/elements/tabs/common/tab-label-common.scss?lit&inline
+var tab_label_common_default = css`:host {
+  --sbb-tab-label-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-2x)
+  );
+  --sbb-tab-label-outline-border-radius-internal: calc(
+    var(--sbb-tab-label-outline-border-radius) - var(--sbb-focus-outline-offset)
+  );
+}
+
+:host(:is(:is(:state(size-s),[state--size-s]), [size=s])) {
+  --sbb-tab-label-height: var(--sbb-size-element-xs);
+  --sbb-tab-label-inline-padding: var(--sbb-spacing-responsive-xxxs);
+  --sbb-tab-label-font-size: var(--sbb-text-font-size-s);
+}
+
+:host(:is(:is(:state(size-l),[state--size-l]), [size=l])) {
+  --sbb-tab-label-height: var(--sbb-size-element-m);
+  --sbb-tab-label-inline-padding: var(--sbb-spacing-responsive-xs);
+  --sbb-tab-label-font-size: var(--sbb-text-font-size-m);
+}
+
+:host(:is(:is(:state(size-xl),[state--size-xl]), [size=xl])) {
+  --sbb-tab-label-height: var(--sbb-size-element-m);
+  --sbb-tab-label-inline-padding: var(--sbb-spacing-responsive-xs);
+  --sbb-tab-label-font-size: var(--sbb-text-font-size-xl);
+}
+
+:host(sbb-tab-label),
+:host(sbb-tab-nav-bar) ::slotted(a) {
+  pointer-events: var(--sbb-tab-label-pointer-events, unset);
+}
+@media (forced-colors: active) {
+  :host(sbb-tab-label),
+  :host(sbb-tab-nav-bar) ::slotted(a) {
+    --sbb-tab-label-color: ButtonText;
+    --sbb-tab-label-amount-color: ButtonText;
+  }
+}
+
+:host(sbb-tab-nav-bar) ::slotted(a),
+:host(sbb-tab-label) .sbb-tab-label {
+  position: relative;
+  display: flex;
+  align-items: center;
+  gap: var(--sbb-tab-label-gap);
+  color: var(--sbb-tab-label-color);
+  margin: 0;
+  padding-inline: var(--sbb-tab-label-inline-padding);
+  min-height: var(--sbb-tab-label-height);
+  transition: color var(--sbb-tab-label-animation-duration) var(--sbb-tab-label-animation-easing);
+  font-size: var(--sbb-tab-label-font-size);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+  font-weight: var(--sbb-tab-label-font-weight);
+  text-decoration: var(--sbb-tab-label-text-decoration);
+}
+:host(sbb-tab-nav-bar) ::slotted(a)::after,
+:host(sbb-tab-label) .sbb-tab-label::after {
+  position: absolute;
+  content: "";
+  inset-inline: 0;
+  inset-block-end: 0;
+  height: var(--sbb-tab-label-marker-thickness);
+  background-color: var(--sbb-tab-label-color);
+  scale: var(--sbb-tab-label-marker-scale, 0);
+  transition-duration: var(--sbb-tab-label-animation-duration);
+  transition-timing-function: var(--sbb-tab-label-animation-easing);
+  transition-property: scale, background-color;
+}
+
+:host(sbb-tab-nav-bar) .sbb-tab-nav-bar > [data-has-divider],
+:host(sbb-tab-label:is(:state(has-divider),[state--has-divider])) {
+  position: relative;
+}
+:host(sbb-tab-nav-bar) .sbb-tab-nav-bar > [data-has-divider]::before,
+:host(sbb-tab-label:is(:state(has-divider),[state--has-divider]))::before {
+  content: "";
+  position: absolute;
+  inset-inline-start: 0;
+  inset-block-end: 0;
+  width: var(--sbb-tab-group-width);
+  height: var(--sbb-border-width-1x);
+  background-color: var(--sbb-tab-label-line-color);
+}
+
+:host(sbb-tab-nav-bar) ::slotted(a.sbb-disabled),
+:host(sbb-tab-label[disabled]) {
+  --sbb-tab-label-cursor: unset;
+  --sbb-tab-label-pointer-events: none;
+  --sbb-tab-label-text-decoration: line-through;
+}
+@media (forced-colors: active) {
+  :host(sbb-tab-nav-bar) ::slotted(a.sbb-disabled),
+  :host(sbb-tab-label[disabled]) {
+    --sbb-tab-label-color: GrayText;
+    --sbb-tab-label-amount-color: GrayText;
+  }
+}
+
+:host(sbb-tab-nav-bar) ::slotted(a.sbb-active:not(.sbb-disabled)),
+:host(sbb-tab-label[active]:not([disabled])) {
+  --sbb-tab-label-color: var(--sbb-color-3);
+  --sbb-tab-label-cursor: unset;
+  --sbb-tab-label-pointer-events: none;
+  --sbb-tab-label-marker-scale: 1;
+}
+@media (forced-colors: active) {
+  :host(sbb-tab-nav-bar) ::slotted(a.sbb-active:not(.sbb-disabled)),
+  :host(sbb-tab-label[active]:not([disabled])) {
+    --sbb-tab-label-color: ButtonText;
+    --sbb-tab-label-amount-color: ButtonText;
+  }
+}
+
+@media (any-hover: hover) {
+  :host(sbb-tab-nav-bar) ::slotted(a:hover:not(.sbb-disabled)),
+  :host(sbb-tab-label:hover:not([disabled])) {
+    --sbb-tab-label-marker-scale: 1;
+  }
+}
+
+:host(sbb-tab-nav-bar) ::slotted(a:active:not(.sbb-disabled)),
+:host(sbb-tab-label:active) {
+  --sbb-tab-label-color: var(--sbb-color-3);
+}
+@media (forced-colors: active) {
+  :host(sbb-tab-nav-bar) ::slotted(a:active:not(.sbb-disabled)),
+  :host(sbb-tab-label:active) {
+    --sbb-tab-label-color: ButtonText;
+    --sbb-tab-label-amount-color: ButtonText;
+  }
+}
+
+:host(sbb-tab-nav-bar) ::slotted(a:focus-visible),
+:host(sbb-tab-label:focus-visible) .sbb-tab-label {
+  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-tab-label-outline-border-radius-internal);
+}`;
+//#endregion
+export { tab_group_common_default as n, tab_label_common_default as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,292 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, html } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement } from "./core/base-elements.js";
+import { forceType } from "./core/decorators.js";
+import { isLean } from "./core/dom.js";
+import { throttle } from "./core/eventing.js";
+import { ɵstateController } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { ResizeController } from "@lit-labs/observers/resize-controller.js";
+import { ref } from "lit/directives/ref.js";
+import { getNextElementIndex, isArrowKeyPressed } from "./core/a11y.js";
+import { tabGroupCommonStyles } from "./tabs/common/styles.js";
+//#region src/elements/tabs/tab-group/tab-group.scss?lit&inline
+var tab_group_default = css`:host {
+  --sbb-tab-group-animation-duration: 0s;
+  gap: var(--sbb-tab-group-content-gap);
+}
+
+:host(:is(:state(initialized),[state--initialized])) {
+  --sbb-tab-group-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-4x)
+  );
+}
+
+.sbb-tab-group-content {
+  height: var(--sbb-tab-content-height);
+  transition: height var(--sbb-tab-group-animation-duration) var(--sbb-animation-easing);
+}
+
+:host([fixed-height]) ::slotted(sbb-tab) {
+  height: 100%;
+  overflow: auto;
+}`;
+//#endregion
+//#region src/elements/tabs/tab-group/tab-group.component.ts
+/**
+* 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.
+*/
+var SbbTabGroupElement = (() => {
+	let _classSuper = SbbElement;
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	let _initialSelectedIndex_decorators;
+	let _initialSelectedIndex_initializers = [];
+	let _initialSelectedIndex_extraInitializers = [];
+	let _fixedHeight_decorators;
+	let _fixedHeight_initializers = [];
+	let _fixedHeight_extraInitializers = [];
+	return class SbbTabGroupElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_size_decorators = [property()];
+			_initialSelectedIndex_decorators = [forceType(), property({
+				attribute: "initial-selected-index",
+				type: Number
+			})];
+			_fixedHeight_decorators = [forceType(), property({
+				attribute: "fixed-height",
+				type: Boolean,
+				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);
+			__esDecorate(this, null, _initialSelectedIndex_decorators, {
+				kind: "accessor",
+				name: "initialSelectedIndex",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "initialSelectedIndex" in obj,
+					get: (obj) => obj.initialSelectedIndex,
+					set: (obj, value) => {
+						obj.initialSelectedIndex = value;
+					}
+				},
+				metadata: _metadata
+			}, _initialSelectedIndex_initializers, _initialSelectedIndex_extraInitializers);
+			__esDecorate(this, null, _fixedHeight_decorators, {
+				kind: "accessor",
+				name: "fixedHeight",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "fixedHeight" in obj,
+					get: (obj) => obj.fixedHeight,
+					set: (obj, value) => {
+						obj.fixedHeight = value;
+					}
+				},
+				metadata: _metadata
+			}, _fixedHeight_initializers, _fixedHeight_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-tab-group";
+		}
+		static {
+			this.styles = [
+				boxSizingStyles,
+				tabGroupCommonStyles,
+				tab_group_default
+			];
+		}
+		static {
+			this.events = { tabchange: "tabchange" };
+		}
+		#size_accessor_storage;
+		/**
+		* Size variant, either s, l or xl.
+		* @default 'l' / 's' (lean)
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		#initialSelectedIndex_accessor_storage;
+		/**
+		* Sets the initial tab. If it matches a disabled tab or exceeds the length of
+		* the tab group, the first enabled tab will be selected.
+		*/
+		get initialSelectedIndex() {
+			return this.#initialSelectedIndex_accessor_storage;
+		}
+		set initialSelectedIndex(value) {
+			this.#initialSelectedIndex_accessor_storage = value;
+		}
+		#fixedHeight_accessor_storage;
+		/**
+		* If set to true, the `sbb-tab` elements take 100% height of the `sbb-tab-group`.
+		* It enables controlling the height on the `sbb-tab-group` element.
+		* The content becomes scrollable on overflow.
+		*/
+		get fixedHeight() {
+			return this.#fixedHeight_accessor_storage;
+		}
+		set fixedHeight(value) {
+			this.#fixedHeight_accessor_storage = value;
+		}
+		/** Gets the slotted `sbb-tab-label`s. */
+		get labels() {
+			/**
+			* The querySelector API is not used because when nested tabs are used,
+			* the returned array contains the inner tabs too, and this breaks the keyboard navigation.
+			*/
+			return Array.from(this.children ?? []).filter((child) => /^sbb-tab-label$/u.test(child.localName));
+		}
+		/** Gets the slotted `sbb-tab`s. */
+		get tabs() {
+			/**
+			* The querySelector API is not used because when nested tabs are used,
+			* the returned array contains the inner tabs too, and this breaks the keyboard navigation.
+			*/
+			return Array.from(this.children ?? []).filter((child) => /^sbb-tab$/u.test(child.localName));
+		}
+		constructor() {
+			super();
+			this._tabGroupResizeObserver = new ResizeController(this, {
+				target: null,
+				skipInitial: true,
+				callback: () => this._onTabGroupElementResize()
+			});
+			this.#size_accessor_storage = __runInitializers(this, _size_initializers, isLean() ? "s" : "l");
+			this.#initialSelectedIndex_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _initialSelectedIndex_initializers, 0));
+			this.#fixedHeight_accessor_storage = (__runInitializers(this, _initialSelectedIndex_extraInitializers), __runInitializers(this, _fixedHeight_initializers, false));
+			this._onContentSlotChange = (__runInitializers(this, _fixedHeight_extraInitializers), () => {
+				this.labels.forEach((tabLabel) => tabLabel["linkToTab"]());
+				this.labels.find((tabLabel) => tabLabel.active)?.activate();
+			});
+			this._onLabelSlotChange = () => {
+				this.labels.forEach((tabLabel) => tabLabel["linkToTab"]());
+				this._ensureActiveTab();
+			};
+			this.addEventListener?.("keydown", (e) => this._handleKeyDown(e));
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this.labels.forEach((tabLabel) => tabLabel["linkToTab"]());
+			this._initSelection();
+			Promise.resolve().then(() => this.internals.states.add("initialized"));
+			this._tabGroupResizeObserver.observe(this._tabGroupElement);
+		}
+		/**
+		* Disables a tab by index.
+		* @param index The index of the tab you want to disable.
+		*/
+		disableTab(index) {
+			if (this.labels[index]) this.labels[index].disabled = true;
+		}
+		/**
+		* Enables a tab by index.
+		* @param index The index of the tab you want to enable.
+		*/
+		enableTab(index) {
+			if (this.labels[index]) this.labels[index].disabled = false;
+		}
+		/**
+		* Activates a tab by index.
+		* @param index The index of the tab you want to activate.
+		*/
+		activateTab(index) {
+			this.labels[index]?.activate();
+		}
+		_enabledTabs() {
+			return this.labels.filter((t) => {
+				customElements.upgrade(t);
+				return !t.disabled;
+			});
+		}
+		_ensureActiveTab() {
+			if (this.internals.states.has("initialized") && !this.labels.some((tabLabel) => tabLabel.active)) this._initSelection();
+		}
+		_initSelection() {
+			const selectedTabLabel = this.labels[this.initialSelectedIndex];
+			if (selectedTabLabel) {
+				customElements.upgrade(selectedTabLabel);
+				if (this.initialSelectedIndex >= 0 && this.initialSelectedIndex < this.labels.length && !selectedTabLabel.disabled) {
+					selectedTabLabel.activate();
+					return;
+				}
+			}
+			this._enabledTabs()[0]?.activate();
+		}
+		_onTabGroupElementResize() {
+			const tabLabels = this.labels;
+			tabLabels.forEach((tabLabel) => {
+				ɵstateController(tabLabel)?.toggle("has-divider", tabLabel === tabLabels[0] || tabLabel.offsetLeft === tabLabels[0].offsetLeft);
+			});
+			this.style.setProperty("--sbb-tab-group-width", `${this._tabGroupElement.clientWidth}px`);
+		}
+		_handleKeyDown(evt) {
+			const enabledTabs = this._enabledTabs();
+			if (!enabledTabs || evt.target !== this && evt.target.parentElement !== this) return;
+			if (isArrowKeyPressed(evt)) {
+				const nextIndex = getNextElementIndex(evt, enabledTabs.findIndex((t) => t.active), enabledTabs.length);
+				enabledTabs[nextIndex]?.activate();
+				enabledTabs[nextIndex]?.focus();
+				evt.preventDefault();
+			}
+		}
+		/**
+		* @internal
+		*/
+		setTabContentHeight(contentHeight) {
+			this.style.setProperty("--sbb-tab-content-height", `${contentHeight}px`);
+		}
+		render() {
+			return html`
+      <div
+        class="sbb-tab-group"
+        role="tablist"
+        ${ref((el) => this._tabGroupElement = el)}
+      >
+        <slot name="tab-bar" @slotchange=${this._onLabelSlotChange}></slot>
+      </div>
+      ${!this.fixedHeight ? html`
+            <div class="sbb-tab-group-content">
+              <slot @slotchange=${throttle(this._onContentSlotChange, 150)}></slot>
+            </div>
+          ` : html`<slot @slotchange=${throttle(this._onContentSlotChange, 150)}></slot>`}
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbTabGroupElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tab-group.component-C6jlhxvZ.js","names":[],"sources":["../../../src/elements/tabs/tab-group/tab-group.scss?lit&inline","../../../src/elements/tabs/tab-group/tab-group.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --sbb-tab-group-animation-duration: 0s;\n\n  gap: var(--sbb-tab-group-content-gap);\n}\n\n:host(:state(initialized)) {\n  --sbb-tab-group-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-4x)\n  );\n}\n\n.sbb-tab-group-content {\n  height: var(--sbb-tab-content-height);\n  transition: height var(--sbb-tab-group-animation-duration) var(--sbb-animation-easing);\n}\n\n::slotted(sbb-tab) {\n  :host([fixed-height]) & {\n    height: 100%;\n    overflow: auto;\n  }\n}\n","import { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html } from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport { getNextElementIndex, isArrowKeyPressed } from '../../core/a11y.ts';\nimport { SbbElement } from '../../core/base-elements.ts';\nimport { forceType } from '../../core/decorators.ts';\nimport { isLean } from '../../core/dom.ts';\nimport { throttle } from '../../core/eventing.ts';\nimport { ɵstateController } from '../../core/mixins.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport { tabGroupCommonStyles } from '../common/styles.ts';\nimport type { SbbTabElement } from '../tab/tab.component.ts';\nimport type { SbbTabLabelElement } from '../tab-label/tab-label.component.ts';\n\nimport style from './tab-group.scss?lit&inline';\n\nexport interface SbbTabChangedEventDetails {\n  activeIndex: number;\n  activeTabLabel: SbbTabLabelElement;\n  activeTab: SbbTabElement;\n  previousIndex: number;\n  previousTabLabel: SbbTabLabelElement | undefined;\n  previousTab: SbbTabElement | undefined;\n}\n\n/**\n * It displays one or more tabs, each one with a label and some content.\n *\n * @slot - Use the unnamed slot to add content to the `sbb-tab-group` via `sbb-tab-label` and `sbb-tab` instances.\n * @event {CustomEvent<SbbTabChangedEventDetails>} tabchange - The tabchange event is dispatched when a tab is selected.\n */\nexport class SbbTabGroupElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-tab-group';\n  public static override styles: CSSResultGroup = [boxSizingStyles, tabGroupCommonStyles, style];\n  public static readonly events = {\n    tabchange: 'tabchange',\n  } as const;\n\n  private _tabGroupElement!: HTMLElement;\n  private _tabGroupResizeObserver = new ResizeController(this, {\n    target: null,\n    skipInitial: true,\n    callback: () => this._onTabGroupElementResize(),\n  });\n\n  /**\n   * Size variant, either s, l or xl.\n   * @default 'l' / 's' (lean)\n   */\n  @property()\n  public accessor size: 's' | 'l' | 'xl' = isLean() ? 's' : 'l';\n\n  /**\n   * Sets the initial tab. If it matches a disabled tab or exceeds the length of\n   * the tab group, the first enabled tab will be selected.\n   */\n  @forceType()\n  @property({ attribute: 'initial-selected-index', type: Number })\n  public accessor initialSelectedIndex: number = 0;\n\n  /**\n   * If set to true, the `sbb-tab` elements take 100% height of the `sbb-tab-group`.\n   * It enables controlling the height on the `sbb-tab-group` element.\n   * The content becomes scrollable on overflow.\n   */\n  @forceType()\n  @property({ attribute: 'fixed-height', type: Boolean, reflect: true })\n  public accessor fixedHeight: boolean = false;\n\n  /** Gets the slotted `sbb-tab-label`s. */\n  public get labels(): SbbTabLabelElement[] {\n    /**\n     * The querySelector API is not used because when nested tabs are used,\n     * the returned array contains the inner tabs too, and this breaks the keyboard navigation.\n     */\n    return Array.from(this.children ?? []).filter((child) =>\n      /^sbb-tab-label$/u.test(child.localName),\n    ) as SbbTabLabelElement[];\n  }\n\n  /** Gets the slotted `sbb-tab`s. */\n  public get tabs(): SbbTabElement[] {\n    /**\n     * The querySelector API is not used because when nested tabs are used,\n     * the returned array contains the inner tabs too, and this breaks the keyboard navigation.\n     */\n    return Array.from(this.children ?? []).filter((child) =>\n      /^sbb-tab$/u.test(child.localName),\n    ) as SbbTabElement[];\n  }\n\n  public constructor() {\n    super();\n    this.addEventListener?.('keydown', (e) => this._handleKeyDown(e));\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    this.labels.forEach((tabLabel) => tabLabel['linkToTab']());\n    this._initSelection();\n\n    // To avoid animations on initialization, we have to mark the component as initialized and wait a tick.\n    Promise.resolve().then(() => this.internals.states.add('initialized'));\n    this._tabGroupResizeObserver.observe(this._tabGroupElement);\n  }\n\n  /**\n   * Disables a tab by index.\n   * @param index The index of the tab you want to disable.\n   */\n  public disableTab(index: number): void {\n    if (this.labels[index]) {\n      this.labels[index].disabled = true;\n    }\n  }\n\n  /**\n   * Enables a tab by index.\n   * @param index The index of the tab you want to enable.\n   */\n  public enableTab(index: number): void {\n    if (this.labels[index]) {\n      this.labels[index].disabled = false;\n    }\n  }\n\n  /**\n   * Activates a tab by index.\n   * @param index The index of the tab you want to activate.\n   */\n  public activateTab(index: number): void {\n    this.labels[index]?.activate();\n  }\n\n  private _enabledTabs(): SbbTabLabelElement[] {\n    return this.labels.filter((t) => {\n      customElements.upgrade(t);\n      return !t.disabled;\n    });\n  }\n\n  private _onContentSlotChange = (): void => {\n    this.labels.forEach((tabLabel) => tabLabel['linkToTab']());\n    this.labels.find((tabLabel) => tabLabel.active)?.activate();\n  };\n\n  private _onLabelSlotChange = (): void => {\n    this.labels.forEach((tabLabel) => tabLabel['linkToTab']());\n    this._ensureActiveTab();\n  };\n\n  private _ensureActiveTab(): void {\n    if (\n      this.internals.states.has('initialized') &&\n      !this.labels.some((tabLabel) => tabLabel.active)\n    ) {\n      this._initSelection();\n    }\n  }\n\n  private _initSelection(): void {\n    const selectedTabLabel = this.labels[this.initialSelectedIndex];\n    if (selectedTabLabel) {\n      customElements.upgrade(selectedTabLabel);\n      if (\n        this.initialSelectedIndex >= 0 &&\n        this.initialSelectedIndex < this.labels.length &&\n        !selectedTabLabel.disabled\n      ) {\n        selectedTabLabel.activate();\n        return;\n      }\n    }\n    this._enabledTabs()[0]?.activate();\n  }\n\n  private _onTabGroupElementResize(): void {\n    const tabLabels = this.labels;\n    tabLabels.forEach((tabLabel) => {\n      ɵstateController(tabLabel)?.toggle(\n        'has-divider',\n        tabLabel === tabLabels[0] || tabLabel.offsetLeft === tabLabels[0].offsetLeft,\n      );\n    });\n\n    this.style.setProperty('--sbb-tab-group-width', `${this._tabGroupElement.clientWidth}px`);\n  }\n\n  private _handleKeyDown(evt: KeyboardEvent): void {\n    const enabledTabs: SbbTabLabelElement[] = this._enabledTabs();\n\n    if (\n      !enabledTabs ||\n      // don't trap nested handling\n      ((evt.target as HTMLElement) !== this && (evt.target as HTMLElement).parentElement !== this)\n    ) {\n      return;\n    }\n\n    if (isArrowKeyPressed(evt)) {\n      const current: number = enabledTabs.findIndex((t) => t.active);\n      const nextIndex: number = getNextElementIndex(evt, current, enabledTabs.length);\n      enabledTabs[nextIndex]?.activate();\n      enabledTabs[nextIndex]?.focus();\n      evt.preventDefault();\n    }\n  }\n\n  /**\n   * @internal\n   */\n  protected setTabContentHeight(contentHeight: number): void {\n    this.style.setProperty('--sbb-tab-content-height', `${contentHeight}px`);\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div\n        class=\"sbb-tab-group\"\n        role=\"tablist\"\n        ${ref((el?: Element) => (this._tabGroupElement = el as HTMLElement))}\n      >\n        <slot name=\"tab-bar\" @slotchange=${this._onLabelSlotChange}></slot>\n      </div>\n      ${!this.fixedHeight\n        ? html`\n            <div class=\"sbb-tab-group-content\">\n              <slot @slotchange=${throttle(this._onContentSlotChange, 150)}></slot>\n            </div>\n          `\n        : html`<slot @slotchange=${throttle(this._onContentSlotChange, 150)}></slot>`}\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-tab-group': SbbTabGroupElement;\n  }\n}\n"],"mappings":"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"}