@sbb-esta/lyne-elements 4.8.1 → 4.10.0

package/development/header.component-Cg0ZcA1s.js

@@ -0,0 +1,340 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, unsafeCSS } from "lit";
+import { property, state } from "lit/decorators.js";
+import { SbbElement } from "./core/base-elements.js";
+import { forceType, idReference } from "./core/decorators.js";
+import { isLean, queueDomContentLoaded } from "./core/dom.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { SbbFocusVisibleWithinController } from "./core/a11y.js";
+//#region src/elements/header/header/header.scss?inline
+var header_default = ":host {\n  --sbb-logo-height: 1rem;\n  --sbb-signet-height: 1rem;\n  --sbb-header-transition-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n}\n@media (min-width: calc(64rem)) {\n  :host {\n    --sbb-logo-height: 1.25rem;\n    --sbb-signet-height: 1.25rem;\n  }\n}\n:host {\n  display: block;\n  height: var(--sbb-header-height);\n}\n\n:host([size=s]) ::slotted(:is(sbb-header-button, sbb-header-link)) {\n  --sbb-header-action-min-height: var(--sbb-size-element-xs);\n  --sbb-header-action-padding-inline: var(--sbb-spacing-fixed-4x);\n}\n\n:host([hide-on-scroll]) {\n  --sbb-header-position: absolute;\n}\n\n:host([hide-on-scroll]:is(:state(fixed),[state--fixed])) {\n  --sbb-header-position: fixed;\n  --sbb-header-animation-name: hide;\n  --sbb-header-transform: translate3d(0, -100%, 0);\n  --sbb-header-inset-inline-end: var(--sbb-scrollbar-width, 0);\n}\n\n:host([hide-on-scroll]:is(:state(fixed),[state--fixed]):is(:state(animated),[state--animated])) {\n  --sbb-header-transition-timing: cubic-bezier(0.4, 0, 1, 1);\n}\n\n:host([hide-on-scroll]:is(:state(fixed),[state--fixed]):is(:state(visible),[state--visible])) {\n  --sbb-header-animation-name: show;\n  --sbb-header-transform: translate3d(0, 0, 0);\n  --sbb-header-transition-timing: cubic-bezier(0, 0, 0.2, 1);\n}\n\n:host([hide-on-scroll]:is(:state(fixed),[state--fixed]):is(:state(has-visible-focus-within),[state--has-visible-focus-within])) {\n  --sbb-header-transition-duration: 0;\n  --sbb-header-transform: translate3d(0, 0, 0);\n}\n\n.sbb-header {\n  position: var(--sbb-header-position);\n  inset: 0 var(--sbb-header-inset-inline-end) auto 0;\n  background: var(--sbb-header-background);\n  z-index: var(--sbb-header-z-index, 10);\n  transform: var(--sbb-header-transform);\n  transition-property: box-shadow;\n  transition-duration: var(--sbb-header-transition-duration);\n  transition-timing-function: var(--sbb-header-transition-timing);\n  animation-name: var(--sbb-header-animation-name);\n  animation-duration: var(--sbb-header-transition-duration);\n  animation-timing-function: var(--sbb-header-transition-timing);\n}\n:host(:is(:is(:state(shadow),[state--shadow]), :is(:state(has-visible-focus-within),[state--has-visible-focus-within]):is(:state(fixed),[state--fixed]))) .sbb-header {\n  box-shadow: var(--sbb-header-box-shadow);\n}\n@media (forced-colors: active) {\n  .sbb-header {\n    border-block-end: var(--sbb-border-width-1x) solid CanvasText;\n  }\n}\n\n.sbb-header__wrapper {\n  display: flex;\n  align-items: center;\n  justify-content: flex-start;\n  height: var(--sbb-header-height);\n}\n:host(:not([expanded])) .sbb-header__wrapper {\n  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));\n  margin-inline: auto;\n  width: 100%;\n}\n@media (min-width: calc(90rem)) {\n  :host(:not([expanded])) .sbb-header__wrapper {\n    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));\n  }\n}\n:host([expanded]) .sbb-header__wrapper {\n  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-spacing-responsive-xxs));\n}\n\n::slotted(:is(sbb-header-button, sbb-header-link):first-child) {\n  margin-inline-start: var(--sbb-header-first-item-margin-inline-start);\n}\n\n::slotted(*) {\n  flex: 0 0 auto;\n}\n\n::slotted(.sbb-header-shrinkable) {\n  flex-shrink: 1;\n  min-width: 0;\n}\n\n::slotted(.sbb-header-spacer) {\n  flex-grow: 1;\n}\n\n::slotted(.sbb-header-logo) {\n  margin-inline-start: var(--sbb-spacing-responsive-s);\n}\n\n::slotted(a.sbb-header-logo) {\n  display: block;\n  padding-block: var(--sbb-spacing-fixed-3x);\n  position: relative;\n  outline: none !important;\n}\n\n::slotted(a.sbb-header-logo)::before {\n  content: \"\";\n  display: block;\n  position: absolute;\n  inset: var(--sbb-spacing-fixed-3x) 0;\n}\n\n::slotted(a.sbb-header-logo:focus-visible)::before {\n  outline-offset: var(--sbb-focus-outline-offset);\n  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);\n  outline-offset: var(--sbb-spacing-fixed-3x);\n  border-radius: 1px;\n}\n\n@keyframes show {\n  from {\n    transform: translate3d(0, -100%, 0);\n  }\n  to {\n    transform: translate3d(0, 0, 0);\n  }\n}\n@keyframes hide {\n  from {\n    transform: translate3d(0, 0, 0);\n  }\n  to {\n    transform: translate3d(0, -100%, 0);\n  }\n}";
+//#endregion
+//#region src/elements/header/header/header.component.ts
+var IS_MENU_OPENED_QUERY = "[aria-controls][aria-expanded='true']";
+/**
+* It displays a header section for the page.
+*
+* @slot - Use the unnamed slot to add actions, content and logo to the header.
+* @cssprop [--sbb-header-z-index=10] - Can be used to modify the z-index of the header.
+* @cssprop [--sbb-header-height=zero-small:var(--sbb-spacing-fixed-14x);large-ultra:var(--sbb-spacing-fixed-24x)] - Can be used to modify height of the header.
+*/
+var SbbHeaderElement = (() => {
+	let _classSuper = SbbElement;
+	let _expanded_decorators;
+	let _expanded_initializers = [];
+	let _expanded_extraInitializers = [];
+	let _scrollOrigin_decorators;
+	let _scrollOrigin_initializers = [];
+	let _scrollOrigin_extraInitializers = [];
+	let _hideOnScroll_decorators;
+	let _hideOnScroll_initializers = [];
+	let _hideOnScroll_extraInitializers = [];
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	let __headerOnTop_decorators;
+	let __headerOnTop_initializers = [];
+	let __headerOnTop_extraInitializers = [];
+	return class SbbHeaderElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_expanded_decorators = [forceType(), property({
+				reflect: true,
+				type: Boolean
+			})];
+			_scrollOrigin_decorators = [idReference(), property({ attribute: "scroll-origin" })];
+			_hideOnScroll_decorators = [forceType(), property({
+				attribute: "hide-on-scroll",
+				reflect: true,
+				type: Boolean
+			})];
+			_size_decorators = [property({ reflect: true })];
+			__headerOnTop_decorators = [state()];
+			__esDecorate(this, null, _expanded_decorators, {
+				kind: "accessor",
+				name: "expanded",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "expanded" in obj,
+					get: (obj) => obj.expanded,
+					set: (obj, value) => {
+						obj.expanded = value;
+					}
+				},
+				metadata: _metadata
+			}, _expanded_initializers, _expanded_extraInitializers);
+			__esDecorate(this, null, _scrollOrigin_decorators, {
+				kind: "accessor",
+				name: "scrollOrigin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "scrollOrigin" in obj,
+					get: (obj) => obj.scrollOrigin,
+					set: (obj, value) => {
+						obj.scrollOrigin = value;
+					}
+				},
+				metadata: _metadata
+			}, _scrollOrigin_initializers, _scrollOrigin_extraInitializers);
+			__esDecorate(this, null, _hideOnScroll_decorators, {
+				kind: "accessor",
+				name: "hideOnScroll",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "hideOnScroll" in obj,
+					get: (obj) => obj.hideOnScroll,
+					set: (obj, value) => {
+						obj.hideOnScroll = value;
+					}
+				},
+				metadata: _metadata
+			}, _hideOnScroll_initializers, _hideOnScroll_extraInitializers);
+			__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, __headerOnTop_decorators, {
+				kind: "accessor",
+				name: "_headerOnTop",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_headerOnTop" in obj,
+					get: (obj) => obj._headerOnTop,
+					set: (obj, value) => {
+						obj._headerOnTop = value;
+					}
+				},
+				metadata: _metadata
+			}, __headerOnTop_initializers, __headerOnTop_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-header";
+		}
+		static {
+			this.styles = [boxSizingStyles, unsafeCSS(header_default)];
+		}
+		static {
+			this._headerScrollOrigins = /* @__PURE__ */ new Set();
+		}
+		static {
+			this._headerElements = /* @__PURE__ */ new Set();
+		}
+		static {
+			if (!isServer) queueDomContentLoaded(() => this._initializeScrollOriginObserver());
+		}
+		#expanded_accessor_storage;
+		/**
+		* Whether to allow the header content to stretch to full width.
+		* By default, the content has the appropriate page size.
+		*/
+		get expanded() {
+			return this.#expanded_accessor_storage;
+		}
+		set expanded(value) {
+			this.#expanded_accessor_storage = value;
+		}
+		#scrollOrigin_accessor_storage;
+		/**
+		* The element's id or the element on which the scroll listener is attached.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get scrollOrigin() {
+			return this.#scrollOrigin_accessor_storage;
+		}
+		set scrollOrigin(value) {
+			this.#scrollOrigin_accessor_storage = value;
+		}
+		#hideOnScroll_accessor_storage;
+		/** Whether the header should hide and show on scroll. */
+		get hideOnScroll() {
+			return this.#hideOnScroll_accessor_storage;
+		}
+		set hideOnScroll(value) {
+			this.#hideOnScroll_accessor_storage = value;
+		}
+		#size_accessor_storage;
+		/**
+		* Size of the header, either m or s.
+		* @default 'm' / 's' (lean)
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		#_headerOnTop_accessor_storage;
+		get _headerOnTop() {
+			return this.#_headerOnTop_accessor_storage;
+		}
+		set _headerOnTop(value) {
+			this.#_headerOnTop_accessor_storage = value;
+		}
+		constructor() {
+			super();
+			this.#expanded_accessor_storage = __runInitializers(this, _expanded_initializers, false);
+			this.#scrollOrigin_accessor_storage = (__runInitializers(this, _expanded_extraInitializers), __runInitializers(this, _scrollOrigin_initializers, null));
+			this.#hideOnScroll_accessor_storage = (__runInitializers(this, _scrollOrigin_extraInitializers), __runInitializers(this, _hideOnScroll_initializers, false));
+			this.#size_accessor_storage = (__runInitializers(this, _hideOnScroll_extraInitializers), __runInitializers(this, _size_initializers, isLean() ? "s" : "m"));
+			this.#_headerOnTop_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, __headerOnTop_initializers, true));
+			this._scrollElement = __runInitializers(this, __headerOnTop_extraInitializers);
+			this._lastScroll = 0;
+			this._scrollOriginFromObserver = null;
+			this.addController(new SbbFocusVisibleWithinController(this));
+		}
+		static _initializeScrollOriginObserver() {
+			new MutationObserver((mutations) => {
+				for (const mutation of mutations) if (mutation.type === "attributes") this._handleScrollOriginElement(mutation.target);
+				else if (mutation.type === "childList") for (const node of [...mutation.addedNodes, ...mutation.removedNodes].filter((n) => n.nodeType === n.ELEMENT_NODE)) {
+					this._handleScrollOriginElement(node);
+					this._findAndHandleScrollOrigins(node);
+				}
+				this._updateHeaderElements();
+			}).observe(document.documentElement, {
+				attributeFilter: ["sbb-header-scroll-origin"],
+				childList: true,
+				subtree: true
+			});
+			this._findAndHandleScrollOrigins(document.body);
+			this._updateHeaderElements();
+		}
+		static _findAndHandleScrollOrigins(root) {
+			root.querySelectorAll("[sbb-header-scroll-origin]").forEach((e) => this._handleScrollOriginElement(e));
+		}
+		static _handleScrollOriginElement(element) {
+			if (element.isConnected && element.hasAttribute("sbb-header-scroll-origin")) this._headerScrollOrigins.add(element);
+			else this._headerScrollOrigins.delete(element);
+		}
+		static _updateHeaderElements() {
+			for (const header of this._headerElements) {
+				if (this._headerScrollOrigins.size === 0) header._scrollOriginFromObserver = null;
+				else if (this._headerScrollOrigins.size === 1) header._scrollOriginFromObserver = this._headerScrollOrigins.values().next().value ?? null;
+				else header._scrollOriginFromObserver = Array.from(this._headerScrollOrigins).sort((c1, c2) => c1.compareDocumentPosition(c2) & Node.DOCUMENT_POSITION_CONTAINS).at(-1) ?? null;
+				header._updateScrollListener();
+			}
+		}
+		/** If `hideOnScroll` is set, checks the element to hook the listener on, and possibly add it.*/
+		connectedCallback() {
+			super.connectedCallback();
+			SbbHeaderElement._headerElements.add(this);
+			if (this.hasUpdated) this._updateScrollListener();
+		}
+		/** Removes the scroll listener, if previously attached. */
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this._scrollElement = null;
+			this._scrollEventsController?.abort();
+			SbbHeaderElement._headerElements.delete(this);
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (!isServer && (!name || name === "scrollOrigin") && this.hasUpdated) this._updateScrollListener();
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this._updateScrollListener();
+		}
+		_updateScrollListener() {
+			const scrollElement = this.scrollOrigin ?? this._scrollOriginFromObserver ?? document;
+			if (scrollElement === this._scrollElement) return;
+			this._scrollEventsController?.abort();
+			this._scrollElement = scrollElement;
+			if (!this._scrollElement) return;
+			this._scrollEventsController = new AbortController();
+			this._scrollFunction = this._getScrollFunction.bind(this);
+			this._scrollElement.addEventListener("scroll", this._scrollFunction, {
+				passive: true,
+				signal: this._scrollEventsController.signal
+			});
+			const currentScroll = this._getCurrentScrollProperty("scrollTop");
+			this._lastScroll = currentScroll <= 0 ? 0 : currentScroll;
+		}
+		/** Returns the correct function to attach on scroll. */
+		_getScrollFunction() {
+			return this.hideOnScroll ? this._scrollListener() : this._scrollShadowListener();
+		}
+		/** Returns the requested property of the scrollContext. */
+		_getCurrentScrollProperty(property) {
+			if (this._scrollElement instanceof Document) return this._scrollElement.documentElement[property] || this._scrollElement.body[property];
+			return this._scrollElement?.[property] || 0;
+		}
+		/**
+		* Sets the correct value for `scrollTop`, then:
+		* - apply the shadow if the element/document has been scrolled down;
+		* - hides the header, remove the shadow and possibly close any open menu on the header if it is not visible anymore;
+		* - shows the header and re-apply the shadow if the element/document has been scrolled up.
+		*/
+		_scrollListener() {
+			const currentScroll = this._getCurrentScrollProperty("scrollTop");
+			if (this._getCurrentScrollProperty("scrollHeight") - window.innerHeight - currentScroll <= 0) return;
+			this.toggleState("shadow", currentScroll !== 0);
+			if (currentScroll > this.offsetHeight && currentScroll > 0 && this._lastScroll < currentScroll) this._closeOpenOverlays();
+			if (currentScroll > this.offsetHeight * 2) {
+				this._headerOnTop = false;
+				if (currentScroll > 0 && this._lastScroll < currentScroll) ["shadow", "visible"].forEach((name) => this.internals.states.delete(name));
+				else [
+					"fixed",
+					"shadow",
+					"animated",
+					"visible"
+				].forEach((name) => this.internals.states.add(name));
+			} else {
+				if (currentScroll === 0) this._headerOnTop = true;
+				if (this._headerOnTop) [
+					"shadow",
+					"animated",
+					"fixed",
+					"visible"
+				].forEach((name) => this.internals.states.delete(name));
+			}
+			this._lastScroll = currentScroll <= 0 ? 0 : currentScroll;
+		}
+		/** Apply the shadow if the element/document has been scrolled down. */
+		_scrollShadowListener() {
+			this.toggleState("shadow", this._getCurrentScrollProperty("scrollTop") !== 0);
+		}
+		_closeOpenOverlays() {
+			if (this.matches(":is(:state(has-visible-focus-within),[state--has-visible-focus-within])")) return;
+			const overlayTriggers = Array.from(this.querySelectorAll(IS_MENU_OPENED_QUERY));
+			for (const overlayTrigger of overlayTriggers) {
+				const overlayId = overlayTrigger.getAttribute("aria-controls");
+				const overlay = document.getElementById(overlayId);
+				if (typeof overlay?.close === "function") overlay.close();
+			}
+		}
+		render() {
+			return html`
+      <header class="sbb-header">
+        <div class="sbb-header__wrapper">
+          <slot></slot>
+        </div>
+      </header>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbHeaderElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"header.component-Cg0ZcA1s.js","names":[],"sources":["../../../src/elements/header/header/header.scss?inline","../../../src/elements/header/header/header.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --sbb-logo-height: #{sbb.px-to-rem-build(16)};\n  --sbb-signet-height: #{sbb.px-to-rem-build(16)};\n  --sbb-header-transition-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n\n  @include sbb.mq($from: large) {\n    --sbb-logo-height: #{sbb.px-to-rem-build(20)};\n    --sbb-signet-height: #{sbb.px-to-rem-build(20)};\n  }\n\n  display: block;\n\n  // Setting the height here reserves the space for the header which will else be lost with fixed position.\n  height: var(--sbb-header-height);\n}\n\n:host([size='s']) {\n  ::slotted(:is(sbb-header-button, sbb-header-link)) {\n    --sbb-header-action-min-height: var(--sbb-size-element-xs);\n    --sbb-header-action-padding-inline: var(--sbb-spacing-fixed-4x);\n  }\n}\n\n:host([hide-on-scroll]) {\n  --sbb-header-position: absolute;\n}\n\n:host([hide-on-scroll]:state(fixed)) {\n  --sbb-header-position: fixed;\n  --sbb-header-animation-name: hide;\n  --sbb-header-transform: translate3d(0, -100%, 0);\n  --sbb-header-inset-inline-end: var(--sbb-scrollbar-width, 0);\n}\n\n:host([hide-on-scroll]:state(fixed):state(animated)) {\n  // Hide transition\n  --sbb-header-transition-timing: cubic-bezier(0.4, 0, 1, 1);\n}\n\n:host([hide-on-scroll]:state(fixed):state(visible)) {\n  --sbb-header-animation-name: show;\n  --sbb-header-transform: translate3d(0, 0, 0);\n\n  // Show transition\n  --sbb-header-transition-timing: cubic-bezier(0, 0, 0.2, 1);\n}\n\n:host([hide-on-scroll]:state(fixed):state(has-visible-focus-within)) {\n  --sbb-header-transition-duration: 0;\n  --sbb-header-transform: translate3d(0, 0, 0);\n}\n\n.sbb-header {\n  position: var(--sbb-header-position);\n  inset: 0 var(--sbb-header-inset-inline-end) auto 0;\n  background: var(--sbb-header-background);\n  z-index: var(--sbb-header-z-index, 10);\n  transform: var(--sbb-header-transform);\n  transition: {\n    property: box-shadow;\n    duration: var(--sbb-header-transition-duration);\n    timing-function: var(--sbb-header-transition-timing);\n  }\n  animation: {\n    name: var(--sbb-header-animation-name);\n    duration: var(--sbb-header-transition-duration);\n    timing-function: var(--sbb-header-transition-timing);\n  }\n\n  :host(:is(:state(shadow), :state(has-visible-focus-within):state(fixed))) & {\n    box-shadow: var(--sbb-header-box-shadow);\n  }\n\n  @include sbb.if-forced-colors {\n    border-block-end: var(--sbb-border-width-1x) solid CanvasText;\n  }\n}\n\n.sbb-header__wrapper {\n  display: flex;\n  align-items: center;\n  justify-content: flex-start;\n  height: var(--sbb-header-height);\n\n  :host(:not([expanded])) & {\n    @include sbb.page-spacing;\n  }\n\n  :host([expanded]) & {\n    @include sbb.page-spacing-expanded;\n  }\n}\n\n// Fix left offset if first element of the header is a sbb-header-button/sbb-header-link.\n// The value of the offset is calculated inside sbb-header-button/sbb-header-link styles.\n::slotted(:is(sbb-header-button, sbb-header-link):first-child) {\n  margin-inline-start: var(--sbb-header-first-item-margin-inline-start);\n}\n\n::slotted(*) {\n  flex: 0 0 auto;\n}\n\n::slotted(.sbb-header-shrinkable) {\n  flex-shrink: 1;\n  min-width: 0;\n}\n\n::slotted(.sbb-header-spacer) {\n  flex-grow: 1;\n}\n\n::slotted(.sbb-header-logo) {\n  margin-inline-start: var(--sbb-spacing-responsive-s);\n}\n\n// Apply padding and outline to possible slotted link in logo slot\n::slotted(a.sbb-header-logo) {\n  display: block;\n  padding-block: var(--sbb-spacing-fixed-3x);\n  position: relative;\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// To show the correct outline, we need to span a hidden element filling the link but without the outline-offset.\n::slotted(a.sbb-header-logo)::before {\n  content: '';\n  display: block;\n  position: absolute;\n  inset: var(--sbb-spacing-fixed-3x) 0;\n}\n\n::slotted(a.sbb-header-logo:focus-visible)::before {\n  @include sbb.focus-outline;\n\n  outline-offset: var(--sbb-spacing-fixed-3x);\n\n  // As if the outline has an offset, the border radius increases, we set it to the smallest possible border-radius.\n  border-radius: 1px;\n}\n\n@keyframes show {\n  from {\n    transform: translate3d(0, -100%, 0);\n  }\n\n  to {\n    transform: translate3d(0, 0, 0);\n  }\n}\n\n@keyframes hide {\n  from {\n    transform: translate3d(0, 0, 0);\n  }\n\n  to {\n    transform: translate3d(0, -100%, 0);\n  }\n}\n","import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  type PropertyDeclaration,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport { SbbFocusVisibleWithinController } from '../../core/a11y.ts';\nimport { SbbElement } from '../../core/base-elements.ts';\nimport { forceType, idReference } from '../../core/decorators.ts';\nimport { isLean, queueDomContentLoaded } from '../../core/dom.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\n\nimport style from './header.scss?inline';\n\nconst IS_MENU_OPENED_QUERY = \"[aria-controls][aria-expanded='true']\";\n\n/**\n * It displays a header section for the page.\n *\n * @slot - Use the unnamed slot to add actions, content and logo to the header.\n * @cssprop [--sbb-header-z-index=10] - Can be used to modify the z-index of the header.\n * @cssprop [--sbb-header-height=zero-small:var(--sbb-spacing-fixed-14x);large-ultra:var(--sbb-spacing-fixed-24x)] - Can be used to modify height of the header.\n */\nexport class SbbHeaderElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-header';\n  public static override styles: CSSResultGroup = [boxSizingStyles, unsafeCSS(style)];\n\n  private static _headerScrollOrigins = new Set<HTMLElement>();\n  private static _headerElements = new Set<SbbHeaderElement>();\n\n  static {\n    if (!isServer) {\n      // We don't want to block execution for initialization,\n      // so we defer it until the DOM content is loaded.\n      queueDomContentLoaded(() => this._initializeScrollOriginObserver());\n    }\n  }\n\n  /**\n   * Whether to allow the header content to stretch to full width.\n   * By default, the content has the appropriate page size.\n   */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor expanded: boolean = false;\n\n  /**\n   * The element's id or the element on which the scroll listener is attached.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property({ attribute: 'scroll-origin' })\n  public accessor scrollOrigin: HTMLElement | null = null;\n\n  /** Whether the header should hide and show on scroll. */\n  @forceType()\n  @property({ attribute: 'hide-on-scroll', reflect: true, type: Boolean })\n  public accessor hideOnScroll: boolean = false;\n\n  /**\n   * Size of the header, either m or s.\n   * @default 'm' / 's' (lean)\n   */\n  @property({ reflect: true }) public accessor size: 'm' | 's' = isLean() ? 's' : 'm';\n\n  @state() private accessor _headerOnTop = true;\n\n  private _scrollElement: HTMLElement | Document | null | undefined;\n  private _scrollEventsController!: AbortController;\n  private _scrollFunction: (() => void) | undefined;\n  private _lastScroll = 0;\n  private _scrollOriginFromObserver: HTMLElement | null = null;\n\n  public constructor() {\n    super();\n    this.addController(new SbbFocusVisibleWithinController(this));\n  }\n\n  private static _initializeScrollOriginObserver(): void {\n    // We are using MutationObserver directly here, as it will only be called on client side,\n    // and we do not need to disconnect it, as we want it to work during the full lifetime\n    // of the page.\n    new MutationObserver((mutations) => {\n      for (const mutation of mutations) {\n        if (mutation.type === 'attributes') {\n          this._handleScrollOriginElement(mutation.target as HTMLElement);\n        } else if (mutation.type === 'childList') {\n          for (const node of [...mutation.addedNodes, ...mutation.removedNodes].filter(\n            (n): n is HTMLElement => n.nodeType === n.ELEMENT_NODE,\n          )) {\n            this._handleScrollOriginElement(node);\n            this._findAndHandleScrollOrigins(node);\n          }\n        }\n      }\n      this._updateHeaderElements();\n    }).observe(document.documentElement, {\n      attributeFilter: ['sbb-header-scroll-origin'],\n      childList: true,\n      subtree: true,\n    });\n    this._findAndHandleScrollOrigins(document.body);\n    this._updateHeaderElements();\n  }\n\n  private static _findAndHandleScrollOrigins(root: HTMLElement): void {\n    root\n      .querySelectorAll<HTMLElement>('[sbb-header-scroll-origin]')\n      .forEach((e) => this._handleScrollOriginElement(e));\n  }\n\n  private static _handleScrollOriginElement(element: HTMLElement): void {\n    if (element.isConnected && element.hasAttribute('sbb-header-scroll-origin')) {\n      this._headerScrollOrigins.add(element);\n    } else {\n      this._headerScrollOrigins.delete(element);\n    }\n  }\n\n  private static _updateHeaderElements(): void {\n    for (const header of this._headerElements) {\n      if (this._headerScrollOrigins.size === 0) {\n        header._scrollOriginFromObserver = null;\n      } else if (this._headerScrollOrigins.size === 1) {\n        header._scrollOriginFromObserver = this._headerScrollOrigins.values().next().value ?? null;\n      } else {\n        header._scrollOriginFromObserver =\n          Array.from(this._headerScrollOrigins)\n            .sort((c1, c2) => c1.compareDocumentPosition(c2) & Node.DOCUMENT_POSITION_CONTAINS)\n            .at(-1) ?? null;\n      }\n      header._updateScrollListener();\n    }\n  }\n\n  /** If `hideOnScroll` is set, checks the element to hook the listener on, and possibly add it.*/\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    SbbHeaderElement._headerElements.add(this);\n    if (this.hasUpdated) {\n      this._updateScrollListener();\n    }\n  }\n\n  /** Removes the scroll listener, if previously attached. */\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._scrollElement = null;\n    this._scrollEventsController?.abort();\n    SbbHeaderElement._headerElements.delete(this);\n  }\n\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n  ): void {\n    super.requestUpdate(name, oldValue, options);\n\n    if (!isServer && (!name || name === 'scrollOrigin') && this.hasUpdated) {\n      this._updateScrollListener();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._updateScrollListener();\n  }\n\n  private _updateScrollListener(): void {\n    const scrollElement = this.scrollOrigin ?? this._scrollOriginFromObserver ?? document;\n    if (scrollElement === this._scrollElement) {\n      return;\n    }\n\n    this._scrollEventsController?.abort();\n    this._scrollElement = scrollElement;\n    if (!this._scrollElement) {\n      return;\n    }\n    this._scrollEventsController = new AbortController();\n    this._scrollFunction = this._getScrollFunction.bind(this);\n    this._scrollElement.addEventListener('scroll', this._scrollFunction, {\n      passive: true,\n      signal: this._scrollEventsController.signal,\n    });\n\n    const currentScroll = this._getCurrentScrollProperty('scrollTop');\n    // `currentScroll` can be negative, e.g. on mobile; this is not allowed.\n    this._lastScroll = currentScroll <= 0 ? 0 : currentScroll;\n  }\n\n  /** Returns the correct function to attach on scroll. */\n  private _getScrollFunction(): void {\n    return this.hideOnScroll ? this._scrollListener() : this._scrollShadowListener();\n  }\n\n  /** Returns the requested property of the scrollContext. */\n  private _getCurrentScrollProperty(property: 'scrollTop' | 'scrollHeight'): number {\n    if (this._scrollElement instanceof Document) {\n      return this._scrollElement.documentElement[property] || this._scrollElement.body[property];\n    }\n    return this._scrollElement?.[property] || 0;\n  }\n\n  /**\n   * Sets the correct value for `scrollTop`, then:\n   * - apply the shadow if the element/document has been scrolled down;\n   * - hides the header, remove the shadow and possibly close any open menu on the header if it is not visible anymore;\n   * - shows the header and re-apply the shadow if the element/document has been scrolled up.\n   */\n  private _scrollListener(): void {\n    const currentScroll = this._getCurrentScrollProperty('scrollTop');\n\n    // Whether the scroll view is bouncing past the edge of content and back again.\n    if (this._getCurrentScrollProperty('scrollHeight') - window.innerHeight - currentScroll <= 0) {\n      return;\n    }\n\n    this.toggleState('shadow', currentScroll !== 0);\n\n    // Close open overlays when scrolling down if the header is scrolled out of sight.\n    if (\n      currentScroll > this.offsetHeight &&\n      currentScroll > 0 &&\n      this._lastScroll < currentScroll\n    ) {\n      this._closeOpenOverlays();\n    }\n    // Check if the header is scrolled out of sight, scroll position > header height * 2.\n    if (currentScroll > this.offsetHeight * 2) {\n      this._headerOnTop = false;\n      if (currentScroll > 0 && this._lastScroll < currentScroll) {\n        // Scrolling down\n        ['shadow', 'visible'].forEach((name) => this.internals.states.delete(name));\n      } else {\n        // Scrolling up\n        ['fixed', 'shadow', 'animated', 'visible'].forEach((name) =>\n          this.internals.states.add(name),\n        );\n      }\n    } else {\n      // Check if header in its original position, scroll position < header height.\n      // Reset header behavior when scroll hits top of the page, on scroll position = 0.\n      if (currentScroll === 0) {\n        this._headerOnTop = true;\n      }\n      if (this._headerOnTop) {\n        ['shadow', 'animated', 'fixed', 'visible'].forEach((name) =>\n          this.internals.states.delete(name),\n        );\n      }\n    }\n    // `currentScroll` can be negative, e.g. on mobile; this is not allowed.\n    this._lastScroll = currentScroll <= 0 ? 0 : currentScroll;\n  }\n\n  /** Apply the shadow if the element/document has been scrolled down. */\n  private _scrollShadowListener(): void {\n    this.toggleState('shadow', this._getCurrentScrollProperty('scrollTop') !== 0);\n  }\n\n  private _closeOpenOverlays(): void {\n    if (this.matches(':state(has-visible-focus-within)')) {\n      return;\n    }\n    const overlayTriggers: HTMLElement[] = Array.from(\n      this.querySelectorAll(IS_MENU_OPENED_QUERY) as NodeListOf<HTMLElement>,\n    );\n    for (const overlayTrigger of overlayTriggers) {\n      const overlayId: string = overlayTrigger.getAttribute('aria-controls')!;\n      const overlay = document.getElementById(overlayId) as HTMLElement & { close: () => void };\n      if (typeof overlay?.close === 'function') {\n        overlay.close();\n      }\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <header class=\"sbb-header\">\n        <div class=\"sbb-header__wrapper\">\n          <slot></slot>\n        </div>\n      </header>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-header': SbbHeaderElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;ACmBA,IAAM,uBAAuB;;;;;;;;IAShB,0BAAgB;mBAAS;;;;;;;;;;;;;;;;cAAzB,yBAAyB,YAAU;;;2BAmB7C,WAAW,EACX,SAAS;IAAE,SAAS;IAAM,MAAM;IAAS,CAAC,CAAA;+BAQ1C,aAAa,EACb,SAAS,EAAE,WAAW,iBAAiB,CAAC,CAAA;+BAIxC,WAAW,EACX,SAAS;IAAE,WAAW;IAAkB,SAAS;IAAM,MAAM;IAAS,CAAC,CAAA;uBAOvE,SAAS,EAAE,SAAS,MAAM,CAAC,CAAA;+BAE3B,OAAO,CAAA;AAtBR,gBAAA,MAAA,MAAA,sBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,cAAA;KAAA,MAAA,QAAA,IAAgB;KAAQ,MAAA,KAAA,UAAA;AAAA,UAAR,WAAQ;;KAAA;IAAA,UAAA;IAAA,EAAA,wBAAA,4BAAA;AASxB,gBAAA,MAAA,MAAA,0BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,kBAAA;KAAA,MAAA,QAAA,IAAgB;KAAY,MAAA,KAAA,UAAA;AAAA,UAAZ,eAAY;;KAAA;IAAA,UAAA;IAAA,EAAA,4BAAA,gCAAA;AAK5B,gBAAA,MAAA,MAAA,0BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,kBAAA;KAAA,MAAA,QAAA,IAAgB;KAAY,MAAA,KAAA,UAAA;AAAA,UAAZ,eAAY;;KAAA;IAAA,UAAA;IAAA,EAAA,4BAAA,gCAAA;AAMC,gBAAA,MAAA,MAAA,kBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,UAAA;KAAA,MAAA,QAAA,IAAgB;KAAI,MAAA,KAAA,UAAA;AAAA,UAAJ,OAAI;;KAAA;IAAA,UAAA;IAAA,EAAA,oBAAA,wBAAA;AAExC,gBAAA,MAAA,MAAA,0BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,kBAAA;KAAA,MAAA,QAAA,IAAiB;KAAY,MAAA,KAAA,UAAA;AAAA,UAAZ,eAAY;;KAAA;IAAA,UAAA;IAAA,EAAA,4BAAA,gCAAA;;;;;;;;;AA1CN,QAAA,cAAsB;;;AAC/B,QAAA,SAAyB,CAAC,iBAAiB,UAAU,eAAM,CAAC;;;AAEpE,QAAA,uCAAuB,IAAI,KAAkB;;;AAC7C,QAAA,kCAAkB,IAAI,KAAuB;;EAE5D;AACE,OAAI,CAAC,SAGH,6BAA4B,KAAK,iCAAiC,CAAC;;EAUvE;;;;;EAAA,IAAgB,WAAQ;AAAA,UAAA,MAAA;;EAAxB,IAAgB,SAAQ,OAAA;AAAA,SAAA,4BAAA;;EASxB;;;;;;EAAA,IAAgB,eAAY;AAAA,UAAA,MAAA;;EAA5B,IAAgB,aAAY,OAAA;AAAA,SAAA,gCAAA;;EAK5B;;EAAA,IAAgB,eAAY;AAAA,UAAA,MAAA;;EAA5B,IAAgB,aAAY,OAAA;AAAA,SAAA,gCAAA;;EAMC;;;;;EAAA,IAAgB,OAAI;AAAA,UAAA,MAAA;;EAApB,IAAgB,KAAI,OAAA;AAAA,SAAA,wBAAA;;EAExC;EAAA,IAAiB,eAAY;AAAA,UAAA,MAAA;;EAA7B,IAAiB,aAAY,OAAA;AAAA,SAAA,gCAAA;;EAQtC,cAAA;AACE,UAAO;AA/BO,SAAA,4BAAA,kBAAA,MAAA,wBAAoB,MAAK;AASzB,SAAA,iCAAA,kBAAA,MAAA,4BAAA,EAAA,kBAAA,MAAA,4BAAmC,KAAI;AAKvC,SAAA,iCAAA,kBAAA,MAAA,gCAAA,EAAA,kBAAA,MAAA,4BAAwB,MAAK;AAMA,SAAA,yBAAA,kBAAA,MAAA,gCAAA,EAAA,kBAAA,MAAA,oBAAkB,QAAQ,GAAG,MAAM,IAAG;AAEzD,SAAA,iCAAA,kBAAA,MAAA,wBAAA,EAAA,kBAAA,MAAA,4BAAe,KAAI;AAErC,QAAA,iBAAc,kBAAA,MAAA,gCAAA;AAGd,QAAA,cAAc;AACd,QAAA,4BAAgD;AAItD,QAAK,cAAc,IAAI,gCAAgC,KAAK,CAAC;;EAGvD,OAAO,kCAA+B;AAI5C,OAAI,kBAAkB,cAAa;AACjC,SAAK,MAAM,YAAY,UACrB,KAAI,SAAS,SAAS,aACpB,MAAK,2BAA2B,SAAS,OAAsB;aACtD,SAAS,SAAS,YAC3B,MAAK,MAAM,QAAQ,CAAC,GAAG,SAAS,YAAY,GAAG,SAAS,aAAa,CAAC,QACnE,MAAwB,EAAE,aAAa,EAAE,aAC3C,EAAE;AACD,UAAK,2BAA2B,KAAK;AACrC,UAAK,4BAA4B,KAAK;;AAI5C,SAAK,uBAAuB;KAC5B,CAAC,QAAQ,SAAS,iBAAiB;IACnC,iBAAiB,CAAC,2BAA2B;IAC7C,WAAW;IACX,SAAS;IACV,CAAC;AACF,QAAK,4BAA4B,SAAS,KAAK;AAC/C,QAAK,uBAAuB;;EAGtB,OAAO,4BAA4B,MAAiB;AAC1D,QACG,iBAA8B,6BAA6B,CAC3D,SAAS,MAAM,KAAK,2BAA2B,EAAE,CAAC;;EAG/C,OAAO,2BAA2B,SAAoB;AAC5D,OAAI,QAAQ,eAAe,QAAQ,aAAa,2BAA2B,CACzE,MAAK,qBAAqB,IAAI,QAAQ;OAEtC,MAAK,qBAAqB,OAAO,QAAQ;;EAIrC,OAAO,wBAAqB;AAClC,QAAK,MAAM,UAAU,KAAK,iBAAiB;AACzC,QAAI,KAAK,qBAAqB,SAAS,EACrC,QAAO,4BAA4B;aAC1B,KAAK,qBAAqB,SAAS,EAC5C,QAAO,4BAA4B,KAAK,qBAAqB,QAAQ,CAAC,MAAM,CAAC,SAAS;QAEtF,QAAO,4BACL,MAAM,KAAK,KAAK,qBAAqB,CAClC,MAAM,IAAI,OAAO,GAAG,wBAAwB,GAAG,GAAG,KAAK,2BAA2B,CAClF,GAAG,GAAG,IAAI;AAEjB,WAAO,uBAAuB;;;;EAKlB,oBAAiB;AAC/B,SAAM,mBAAmB;AACzB,oBAAiB,gBAAgB,IAAI,KAAK;AAC1C,OAAI,KAAK,WACP,MAAK,uBAAuB;;;EAKhB,uBAAoB;AAClC,SAAM,sBAAsB;AAC5B,QAAK,iBAAiB;AACtB,QAAK,yBAAyB,OAAO;AACrC,oBAAiB,gBAAgB,OAAO,KAAK;;EAG/B,cACd,MACA,UACA,SAA6B;AAE7B,SAAM,cAAc,MAAM,UAAU,QAAQ;AAE5C,OAAI,CAAC,aAAa,CAAC,QAAQ,SAAS,mBAAmB,KAAK,WAC1D,MAAK,uBAAuB;;EAIb,aAAa,mBAAuC;AACrE,SAAM,aAAa,kBAAkB;AACrC,QAAK,uBAAuB;;EAGtB,wBAAqB;GAC3B,MAAM,gBAAgB,KAAK,gBAAgB,KAAK,6BAA6B;AAC7E,OAAI,kBAAkB,KAAK,eACzB;AAGF,QAAK,yBAAyB,OAAO;AACrC,QAAK,iBAAiB;AACtB,OAAI,CAAC,KAAK,eACR;AAEF,QAAK,0BAA0B,IAAI,iBAAiB;AACpD,QAAK,kBAAkB,KAAK,mBAAmB,KAAK,KAAK;AACzD,QAAK,eAAe,iBAAiB,UAAU,KAAK,iBAAiB;IACnE,SAAS;IACT,QAAQ,KAAK,wBAAwB;IACtC,CAAC;GAEF,MAAM,gBAAgB,KAAK,0BAA0B,YAAY;AAEjE,QAAK,cAAc,iBAAiB,IAAI,IAAI;;;EAItC,qBAAkB;AACxB,UAAO,KAAK,eAAe,KAAK,iBAAiB,GAAG,KAAK,uBAAuB;;;EAI1E,0BAA0B,UAAsC;AACtE,OAAI,KAAK,0BAA0B,SACjC,QAAO,KAAK,eAAe,gBAAgB,aAAa,KAAK,eAAe,KAAK;AAEnF,UAAO,KAAK,iBAAiB,aAAa;;;;;;;;EASpC,kBAAe;GACrB,MAAM,gBAAgB,KAAK,0BAA0B,YAAY;AAGjE,OAAI,KAAK,0BAA0B,eAAe,GAAG,OAAO,cAAc,iBAAiB,EACzF;AAGF,QAAK,YAAY,UAAU,kBAAkB,EAAE;AAG/C,OACE,gBAAgB,KAAK,gBACrB,gBAAgB,KAChB,KAAK,cAAc,cAEnB,MAAK,oBAAoB;AAG3B,OAAI,gBAAgB,KAAK,eAAe,GAAG;AACzC,SAAK,eAAe;AACpB,QAAI,gBAAgB,KAAK,KAAK,cAAc,cAE1C,EAAC,UAAU,UAAU,CAAC,SAAS,SAAS,KAAK,UAAU,OAAO,OAAO,KAAK,CAAC;QAG3E;KAAC;KAAS;KAAU;KAAY;KAAU,CAAC,SAAS,SAClD,KAAK,UAAU,OAAO,IAAI,KAAK,CAChC;UAEE;AAGL,QAAI,kBAAkB,EACpB,MAAK,eAAe;AAEtB,QAAI,KAAK,aACP;KAAC;KAAU;KAAY;KAAS;KAAU,CAAC,SAAS,SAClD,KAAK,UAAU,OAAO,OAAO,KAAK,CACnC;;AAIL,QAAK,cAAc,iBAAiB,IAAI,IAAI;;;EAItC,wBAAqB;AAC3B,QAAK,YAAY,UAAU,KAAK,0BAA0B,YAAY,KAAK,EAAE;;EAGvE,qBAAkB;AACxB,OAAI,KAAK,QAAQ,0EAAmC,CAClD;GAEF,MAAM,kBAAiC,MAAM,KAC3C,KAAK,iBAAiB,qBAAgD,CACvE;AACD,QAAK,MAAM,kBAAkB,iBAAiB;IAC5C,MAAM,YAAoB,eAAe,aAAa,gBAAiB;IACvE,MAAM,UAAU,SAAS,eAAe,UAAiD;AACzF,QAAI,OAAO,SAAS,UAAU,WAC5B,SAAQ,OAAO;;;EAKF,SAAM;AACvB,UAAO,IAAI"}

package/development/header.js

@@ -1,8 +1,8 @@
-import { t as SbbHeaderActionCommonElementMixin } from "./header-action-common-BPwn9nFN.js";
+import { t as SbbHeaderActionCommonElementMixin } from "./header-action-common-MTYV0dqA.js";
 import { SbbHeaderButtonElement } from "./header/header-button/header-button.component.js";
-import { t as SbbHeaderEnvironmentElement } from "./header-environment.component-JltjpGKu.js";
+import { t as SbbHeaderEnvironmentElement } from "./header-environment.component-DHqoX_lg.js";
 import { SbbHeaderLinkElement } from "./header/header-link/header-link.component.js";
-import { t as SbbHeaderElement } from "./header.component-DEw_zC-n.js";
+import { t as SbbHeaderElement } from "./header.component-Cg0ZcA1s.js";
 import "./header.pure.js";
 //#region src/elements/header.ts
 /** @entrypoint */

package/development/header.pure.js

@@ -1,6 +1,6 @@
-import { t as SbbHeaderActionCommonElementMixin } from "./header-action-common-BPwn9nFN.js";
+import { t as SbbHeaderActionCommonElementMixin } from "./header-action-common-MTYV0dqA.js";
 import { SbbHeaderButtonElement } from "./header/header-button/header-button.component.js";
-import { t as SbbHeaderEnvironmentElement } from "./header-environment.component-JltjpGKu.js";
+import { t as SbbHeaderEnvironmentElement } from "./header-environment.component-DHqoX_lg.js";
 import { SbbHeaderLinkElement } from "./header/header-link/header-link.component.js";
-import { t as SbbHeaderElement } from "./header.component-DEw_zC-n.js";
+import { t as SbbHeaderElement } from "./header.component-Cg0ZcA1s.js";
 export { SbbHeaderActionCommonElementMixin, SbbHeaderButtonElement, SbbHeaderElement, SbbHeaderEnvironmentElement, SbbHeaderLinkElement };

package/development/hint.component-BsIzdUOV.js

@@ -0,0 +1,38 @@
+import { html, unsafeCSS } from "lit";
+import { SbbElement } from "./core/base-elements.js";
+import { SbbNegativeMixin } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+//#region src/elements/form-field/hint/hint.scss?inline
+var hint_default = ":host {\n  --sbb-form-field-hint-font-size: var(--sbb-text-font-size-xxs);\n  display: inline-block;\n  color: var(--sbb-form-field-label-color);\n  font-size: var(--sbb-form-field-hint-font-size);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n}\n\n:host([negative]) {\n  --sbb-form-field-label-color: var(--sbb-color-5);\n}";
+//#endregion
+//#region src/elements/form-field/hint/hint.component.ts
+/**
+* It displays a hint message in the `sbb-form-field`.
+*
+* @slot - Use the unnamed slot to display the hint message.
+*/
+var SbbHintElement = class extends SbbNegativeMixin(SbbElement) {
+	constructor() {
+		super(...arguments);
+		this.formField = null;
+	}
+	static {
+		this.elementName = "sbb-hint";
+	}
+	static {
+		this.styles = [boxSizingStyles, unsafeCSS(hint_default)];
+	}
+	connectedCallback() {
+		super.connectedCallback();
+		this.slot ||= "hint";
+		this.formField = this.closest?.("sbb-form-field");
+		this.negative = this.formField?.hasAttribute("negative") ?? false;
+	}
+	render() {
+		return html`<slot></slot>`;
+	}
+};
+//#endregion
+export { SbbHintElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/icon/icon-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"icon-base.d.ts","sourceRoot":"","sources":["../../../../src/elements/icon/icon-base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAQ1D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAStD;;;GAGG;AACH,8BAAsB,WAAY,SAAQ,UAAU;IAClD,OAAuB,MAAM,EAAE,cAAc,CAA4B;IACzE,gBAAgC,IAAI,SAAS;IAEpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoB;IAE3D;;OAEG;IACM,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAC3B;IAEP;;;;;OAKG;IACH,SAEgB,UAAU,EAAE,OAAO,CAAS;;cAO5B,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;cAwB5C,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI9E,OAAO,CAAC,cAAc;cAgBH,MAAM,IAAI,cAAc;CAS5C"}
+{"version":3,"file":"icon-base.d.ts","sourceRoot":"","sources":["../../../../src/elements/icon/icon-base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAQ1D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAStD;;;GAGG;AACH,8BAAsB,WAAY,SAAQ,UAAU;IAClD,OAAuB,MAAM,EAAE,cAAc,CAAuC;IACpF,gBAAgC,IAAI,SAAS;IAEpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoB;IAE3D;;OAEG;IACM,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAC3B;IAEP;;;;;OAKG;IACH,SAEgB,UAAU,EAAE,OAAO,CAAS;;cAO5B,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;cAwB5C,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI9E,OAAO,CAAC,cAAc;cAgBH,MAAM,IAAI,cAAc;CAS5C"}

package/development/icon/icon-base.js

@@ -1,2 +1,2 @@
-import { t as SbbIconBase } from "../icon-base-DaK86P0U.js";
+import { t as SbbIconBase } from "../icon-base-DHN9pz2I.js";
 export { SbbIconBase };

package/development/icon/icon-name-mixin.js

@@ -1,4 +1,3 @@
-import "../icon-base-DaK86P0U.js";
 import "./icon.component.js";
 import { __esDecorate, __runInitializers } from "tslib";
 import { html, nothing } from "lit";
@@ -80,4 +79,4 @@ var SbbIconNameMixin = (superClass) => {
 //#endregion
 export { SbbIconNameMixin };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWNvbi1uYW1lLW1peGluLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9pY29uL2ljb24tbmFtZS1taXhpbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBodG1sLCBub3RoaW5nLCB0eXBlIFRlbXBsYXRlUmVzdWx0IH0gZnJvbSAnbGl0JztcbmltcG9ydCB7IHByb3BlcnR5IH0gZnJvbSAnbGl0L2RlY29yYXRvcnMuanMnO1xuXG5pbXBvcnQgdHlwZSB7IFNiYkVsZW1lbnQgfSBmcm9tICcuLi9jb3JlL2Jhc2UtZWxlbWVudHMudHMnO1xuaW1wb3J0IHsgZm9yY2VUeXBlLCBvbWl0RW1wdHlDb252ZXJ0ZXIgfSBmcm9tICcuLi9jb3JlL2RlY29yYXRvcnMudHMnO1xuaW1wb3J0IHR5cGUgeyBBYnN0cmFjdENvbnN0cnVjdG9yLCBTYmJFbGVtZW50SW50ZXJuYWxzTWl4aW5UeXBlIH0gZnJvbSAnLi4vY29yZS9taXhpbnMudHMnO1xuXG5pbXBvcnQgJy4vaWNvbi5jb21wb25lbnQudHMnO1xuXG5leHBvcnQgZGVjbGFyZSBjbGFzcyBTYmJJY29uTmFtZU1peGluVHlwZSB7XG4gIHB1YmxpYyBhY2Nlc3NvciBpY29uTmFtZTogc3RyaW5nO1xuICBwcm90ZWN0ZWQgcmVuZGVySWNvblNsb3QoY2xhc3NuYW1lPzogc3RyaW5nKTogVGVtcGxhdGVSZXN1bHQ7XG4gIHByb3RlY3RlZCByZW5kZXJJY29uTmFtZSgpOiBzdHJpbmc7XG59XG5cbi8qKlxuICogRW5oYW5jZSB5b3VyIGNvbXBvbmVudCB3aXRoIGFuIGljb25OYW1lIHByb3BlcnR5IGFuZCBwcm92aWRlcyBhIHRlbXBsYXRlIGZvciB0aGUgaWNvbiBzbG90LlxuICovXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25hbWluZy1jb252ZW50aW9uXG5leHBvcnQgY29uc3QgU2JiSWNvbk5hbWVNaXhpbiA9IDxcbiAgVCBleHRlbmRzIEFic3RyYWN0Q29uc3RydWN0b3I8U2JiRWxlbWVudCAmIFNiYkVsZW1lbnRJbnRlcm5hbHNNaXhpblR5cGU+LFxuPihcbiAgc3VwZXJDbGFzczogVCxcbik6IEFic3RyYWN0Q29uc3RydWN0b3I8U2JiSWNvbk5hbWVNaXhpblR5cGU+ICYgVCA9PiB7XG4gIGFic3RyYWN0IGNsYXNzIFNiYkljb25OYW1lRWxlbWVudCBleHRlbmRzIHN1cGVyQ2xhc3MgaW1wbGVtZW50cyBQYXJ0aWFsPFNiYkljb25OYW1lTWl4aW5UeXBlPiB7XG4gICAgLyoqXG4gICAgICogVGhlIGljb24gbmFtZSB3ZSB3YW50IHRvIHVzZSwgY2hvb3NlIGZyb20gdGhlIHNtYWxsIGljb24gdmFyaWFudHNcbiAgICAgKiBmcm9tIHRoZSB1aS1pY29ucyBjYXRlZ29yeSBmcm9tIGhlcmVcbiAgICAgKiBodHRwczovL2ljb25zLmFwcC5zYmIuY2guXG4gICAgICovXG4gICAgQGZvcmNlVHlwZSgpXG4gICAgQHByb3BlcnR5KHsgYXR0cmlidXRlOiAnaWNvbi1uYW1lJywgY29udmVydGVyOiBvbWl0RW1wdHlDb252ZXJ0ZXIgfSlcbiAgICBwdWJsaWMgYWNjZXNzb3IgaWNvbk5hbWU6IHN0cmluZyA9ICcnO1xuXG4gICAgcHJvdGVjdGVkIHJlbmRlckljb25TbG90KGNsYXNzbmFtZT86IHN0cmluZyk6IFRlbXBsYXRlUmVzdWx0IHtcbiAgICAgIGNvbnN0IGljb25OYW1lID0gdGhpcy5fcmVuZGVySWNvbk5hbWUoKTtcblxuICAgICAgcmV0dXJuIGh0bWxgXG4gICAgICAgIDxzbG90IG5hbWU9XCJpY29uXCI+XG4gICAgICAgICAgJHtpY29uTmFtZVxuICAgICAgICAgICAgPyBodG1sYDxzYmItaWNvbiBuYW1lPSR7aWNvbk5hbWV9IGNsYXNzPSR7Y2xhc3NuYW1lIHx8IG5vdGhpbmd9Pjwvc2JiLWljb24+YFxuICAgICAgICAgICAgOiBub3RoaW5nfVxuICAgICAgICA8L3Nsb3Q+XG4gICAgICBgO1xuICAgIH1cblxuICAgIHByb3RlY3RlZCByZW5kZXJJY29uTmFtZSgpOiBzdHJpbmcge1xuICAgICAgcmV0dXJuIHRoaXMuaWNvbk5hbWU7XG4gICAgfVxuXG4gICAgcHJpdmF0ZSBfcmVuZGVySWNvbk5hbWUoKTogc3RyaW5nIHtcbiAgICAgIGNvbnN0IGljb25OYW1lID0gdGhpcy5yZW5kZXJJY29uTmFtZSgpO1xuICAgICAgdGhpcy50b2dnbGVTdGF0ZSgnaGFzLWljb24tbmFtZScsICEhaWNvbk5hbWUpO1xuICAgICAgcmV0dXJuIGljb25OYW1lO1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiBTYmJJY29uTmFtZUVsZW1lbnQgYXMgdW5rbm93biBhcyBBYnN0cmFjdENvbnN0cnVjdG9yPFNiYkljb25OYW1lTWl4aW5UeXBlPiAmIFQ7XG59O1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7O0FBbUJBLElBQWEsb0JBR1gsZUFDaUQ7QUFrQ2pELGVBakNpQztvQkFBUzs7OztlQUEzQiwyQkFBMkIsWUFBVTs7OzRCQU1qRCxXQUFXLEVBQ1gsU0FBUztLQUFFLFdBQVc7S0FBYSxXQUFXO0tBQW9CLENBQUMsQ0FBQTtBQUNwRSxpQkFBQSxNQUFBLE1BQUEsc0JBQUE7S0FBQSxNQUFBO0tBQUEsTUFBQTtLQUFBLFFBQUE7S0FBQSxTQUFBO0tBQUEsUUFBQTtNQUFBLE1BQUEsUUFBQSxjQUFBO01BQUEsTUFBQSxRQUFBLElBQWdCO01BQVEsTUFBQSxLQUFBLFVBQUE7QUFBQSxXQUFSLFdBQVE7O01BQUE7S0FBQSxVQUFBO0tBQUEsRUFBQSx3QkFBQSw0QkFBQTs7Ozs7Ozs7R0FBeEIsNkJBQUEsa0JBQUEsTUFBQSx3QkFBbUMsR0FBRTs7Ozs7O0dBQXJDLElBQWdCLFdBQVE7QUFBQSxXQUFBLE1BQUE7O0dBQXhCLElBQWdCLFNBQVEsT0FBQTtBQUFBLFVBQUEsNEJBQUE7O0dBRWQsZUFBZSxXQUFrQjtJQUN6QyxNQUFNLFdBQVcsS0FBSyxpQkFBaUI7QUFFdkMsV0FBTyxJQUFJOztZQUVMLFdBQ0UsSUFBSSxrQkFBa0IsU0FBUSxTQUFVLGFBQWEsUUFBTyxnQkFDNUQsUUFBQTs7OztHQUtBLGlCQUFjO0FBQ3RCLFdBQU8sS0FBSzs7R0FHTixrQkFBZTtJQUNyQixNQUFNLFdBQVcsS0FBSyxnQkFBZ0I7QUFDdEMsU0FBSyxZQUFZLGlCQUFpQixDQUFDLENBQUMsU0FBUztBQUM3QyxXQUFPIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/icon/icon-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"icon-request.d.ts","sourceRoot":"","sources":["../../../../src/elements/icon/icon-request.ts"],"names":[],"mappings":"AAcA,6FAA6F;AAC7F,eAAO,MAAM,aAAa,GACxB,WAAW,MAAM,EACjB,MAAM,MAAM,EACZ,UAAU,OAAO,KAChB,OAAO,CAAC,MAAM,CA6ChB,CAAC"}
+{"version":3,"file":"icon-request.d.ts","sourceRoot":"","sources":["../../../../src/elements/icon/icon-request.ts"],"names":[],"mappings":"AAcA,6FAA6F;AAC7F,eAAO,MAAM,aAAa,GACxB,WAAW,MAAM,EACjB,MAAM,MAAM,EACZ,UAAU,OAAO,KAChB,OAAO,CAAC,MAAM,CA8ChB,CAAC"}

package/development/icon/icon-request.js

@@ -21,7 +21,8 @@ var getSvgContent = (namespace, name, sanitize) => {
 				if (!response.ok) throw new Error(`Failed to load icon ${namespace}:${name}`);
 				return validateContent(await response.text(), sanitize);
 			}).catch((error) => {
-				throw Error(error);
+				console.warn(error);
+				return "";
 			})
 		});
 		requests.set(url, req);
@@ -31,4 +32,4 @@ var getSvgContent = (namespace, name, sanitize) => {
 //#endregion
 export { getSvgContent };
 
-//# 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/icon/icon.component.js

@@ -1,4 +1,4 @@
-import { t as SbbIconBase } from "../icon-base-DaK86P0U.js";
+import { t as SbbIconBase } from "../icon-base-DHN9pz2I.js";
 import { __esDecorate, __runInitializers } from "tslib";
 import { html } from "lit";
 import { property, state } from "lit/decorators.js";