@sbb-esta/lyne-elements 4.7.0 → 4.8.1

package/development/sticky-bar.component-DxDHpEgX.js

@@ -0,0 +1,382 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, html } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement } from "./core/base-elements.js";
+import { isLean, isZeroAnimationDuration } from "./core/dom.js";
+import { SbbUpdateSchedulerMixin } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { IntersectionController } from "@lit-labs/observers/intersection-controller.js";
+//#region src/elements/container/sticky-bar/sticky-bar.scss?lit&inline
+var sticky_bar_default = css`:host {
+  --sbb-sticky-bar-fade-in-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-5x)
+  );
+  --sbb-sticky-bar-fade-out-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-2x)
+  );
+  --sbb-sticky-bar-slide-vertically-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-4x)
+  );
+  --_sbb-sticky-bar-background-animation-duration: var(
+    --sbb-sticky-bar-fade-out-animation-duration
+  );
+  display: contents;
+}
+
+:host([size=s]) {
+  --sbb-sticky-bar-padding-block: var(--sbb-spacing-responsive-xxxs);
+}
+
+:host([size=m]) {
+  --sbb-sticky-bar-padding-block: var(--sbb-spacing-responsive-xs);
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))) {
+  --sbb-sticky-bar-sticky-background-color: var(
+    --sbb-container-background-color,
+    var(--sbb-background-color-1)
+  );
+  --_sbb-sticky-bar-intersector-background-color: var(--sbb-sticky-bar-sticky-background-color);
+  --_sbb-sticky-bar-background-animation-duration: var(--sbb-sticky-bar-fade-in-animation-duration);
+}
+@media (forced-colors: active) {
+  :host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))) {
+    --_sbb-sticky-bar-forced-colors-border: var(--sbb-border-width-1x) solid CanvasText;
+  }
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))[color=white]) {
+  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-1);
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))[color=milk]) {
+  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-3);
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))[color=midnight]) {
+  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-1-negative);
+}
+
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))[color=charcoal]) {
+  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-2-negative);
+}
+
+:host(:is(:is(:state(sticking),[state--sticking]):is(:is(:state(slide-vertically),[state--slide-vertically]), :is(:state(state-sticking),[state--state-sticking]), :is(:state(state-unsticking),[state--state-unsticking])),
+:is(:state(state-unsticky),[state--state-unsticky]))) {
+  --_sbb-sticky-bar-background-animation-duration: 0s;
+}
+
+:host(:is(:state(sticking),[state--sticking]):is(:is(:state(slide-vertically),[state--slide-vertically]):not(:is(:state(state-unsticky),[state--state-unsticky]), :is(:state(state-unsticking),[state--state-unsticking])),
+:is(:state(state-sticking),[state--state-sticking]))) {
+  --sbb-sticky-bar-slide-vertically-animation-name: slide-in;
+}
+
+:host(:is(:state(sticking),[state--sticking]):is(:state(state-unsticking),[state--state-unsticking])) {
+  --sbb-sticky-bar-slide-vertically-animation-name: slide-out;
+}
+
+:host(:is(:not(:is(:state(initialized),[state--initialized])), :is(:state(state-unsticky),[state--state-unsticky]))) {
+  --sbb-sticky-bar-position: relative;
+}
+
+.sbb-sticky-bar__wrapper {
+  position: var(--sbb-sticky-bar-position);
+  inset-block-end: 0;
+  display: block;
+  z-index: var(--sbb-sticky-bar-z-index);
+  animation-name: var(--sbb-sticky-bar-slide-vertically-animation-name, unset);
+  animation-duration: var(--sbb-sticky-bar-slide-vertically-animation-duration);
+  animation-timing-function: var(--sbb-sticky-bar-slide-vertically-animation-easing);
+  animation-delay: 0s;
+  animation-fill-mode: backwards;
+}
+.sbb-sticky-bar__wrapper::after, .sbb-sticky-bar__wrapper::before {
+  content: "";
+  inset: 0;
+  position: absolute;
+  display: block;
+  z-index: -1;
+}
+.sbb-sticky-bar__wrapper::before {
+  background-color: var(--sbb-container-background-color);
+  padding: 0 !important;
+}
+:host(:not(:is(:state(expanded),[state--expanded]))) .sbb-sticky-bar__wrapper::before {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));
+  margin-inline: auto;
+  width: 100%;
+}
+@media (min-width: calc(90rem)) {
+  :host(:not(:is(:state(expanded),[state--expanded]))) .sbb-sticky-bar__wrapper::before {
+    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));
+  }
+}
+.sbb-sticky-bar__wrapper::after {
+  background-color: var(--sbb-sticky-bar-sticky-background-color, transparent);
+  border-start-start-radius: var(--sbb-sticky-bar-border-radius);
+  border-start-end-radius: var(--sbb-sticky-bar-border-radius);
+  transition: background-color var(--_sbb-sticky-bar-background-animation-duration) var(--sbb-sticky-bar-animation-easing);
+  border: var(--_sbb-sticky-bar-forced-colors-border, none);
+}
+
+.sbb-sticky-bar {
+  display: flex;
+  padding-block: var(--sbb-sticky-bar-padding-block);
+  margin-block-end: -1px;
+}
+.sbb-sticky-bar::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  border-start-start-radius: var(--sbb-sticky-bar-border-radius);
+  border-start-end-radius: var(--sbb-sticky-bar-border-radius);
+  transition: box-shadow var(--_sbb-sticky-bar-background-animation-duration) var(--sbb-sticky-bar-animation-easing);
+  clip-path: polygon(-100% calc(-1 * var(--sbb-shadow-elevation-level-11-shadow-1-blur)), 150% calc(-1 * var(--sbb-shadow-elevation-level-11-shadow-1-blur)), 150% 100%, -100% 100%);
+}
+:host(:is(:state(sticking),[state--sticking]):not(:is(:state(state-unsticky),[state--state-unsticky]))) .sbb-sticky-bar::before {
+  box-shadow: var(--sbb-box-shadow-level-11-soft);
+}
+:host(:not(:is(:state(expanded),[state--expanded]))) .sbb-sticky-bar {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));
+  margin-inline: auto;
+  width: 100%;
+}
+@media (min-width: calc(90rem)) {
+  :host(:not(:is(:state(expanded),[state--expanded]))) .sbb-sticky-bar {
+    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));
+  }
+}
+:host(:is(:state(expanded),[state--expanded])) .sbb-sticky-bar {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-spacing-responsive-xxs));
+}
+
+.sbb-sticky-bar__intersector {
+  height: 1px;
+}
+.sbb-sticky-bar__intersector::after {
+  content: "";
+  display: block;
+  position: absolute;
+  width: 100%;
+  height: calc(var(--sbb-sticky-bar-bottom-overlapping-height, 0) + 1px);
+  background-color: var(--_sbb-sticky-bar-intersector-background-color, transparent);
+  pointer-events: none;
+  transition: background-color var(--_sbb-sticky-bar-background-animation-duration) var(--sbb-sticky-bar-animation-easing);
+}
+
+@keyframes slide-in {
+  from {
+    transform: translateY(100%);
+  }
+  to {
+    transform: translateY(0%);
+  }
+}
+@keyframes slide-out {
+  from {
+    transform: translateY(0%);
+  }
+  to {
+    transform: translateY(100%);
+  }
+}`;
+//#endregion
+//#region src/elements/container/sticky-bar/sticky-bar.component.ts
+/**
+* A container that sticks to the bottom of the page if slotted into `sbb-container`.
+*
+* @slot - Use the unnamed slot to add content to the sticky bar.
+* @cssprop [--sbb-sticky-bar-padding-block=var(--sbb-spacing-responsive-xs)] - Block padding of the sticky bar.
+* @cssprop [--sbb-sticky-bar-bottom-overlapping-height=0px] - Define an additional area where
+* the sticky bar overlaps the following content on the bottom.
+* This area becomes visible when the sticky bar transitions from sticky to the normal document flow.
+* @cssprop [--sbb-sticky-bar-z-index] - To specify a custom stack order,
+* the `z-index` can be overridden by defining this CSS variable.
+*/
+var SbbStickyBarElement = (() => {
+	let _classSuper = SbbUpdateSchedulerMixin(SbbElement);
+	let _color_decorators;
+	let _color_initializers = [];
+	let _color_extraInitializers = [];
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	return class SbbStickyBarElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_color_decorators = [property({ reflect: true })];
+			_size_decorators = [property({ reflect: true })];
+			__esDecorate(this, null, _color_decorators, {
+				kind: "accessor",
+				name: "color",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "color" in obj,
+					get: (obj) => obj.color,
+					set: (obj, value) => {
+						obj.color = value;
+					}
+				},
+				metadata: _metadata
+			}, _color_initializers, _color_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);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-sticky-bar";
+		}
+		static {
+			this.styles = [boxSizingStyles, sticky_bar_default];
+		}
+		static {
+			this.events = {
+				beforestick: "beforestick",
+				stick: "stick",
+				beforeunstick: "beforeunstick",
+				unstick: "unstick"
+			};
+		}
+		#color_accessor_storage;
+		/** Color of the container, like transparent, white etc. */
+		get color() {
+			return this.#color_accessor_storage;
+		}
+		set color(value) {
+			this.#color_accessor_storage = value;
+		}
+		#size_accessor_storage;
+		/**
+		* Size of the container.
+		* @default 'm' / 's' (lean)
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		/** The state of the component. */
+		set _state(state) {
+			if (this._stateInternal) this.internals.states.delete(`state-${this._stateInternal}`);
+			this._stateInternal = state;
+			if (this._stateInternal) this.internals.states.add(`state-${this._stateInternal}`);
+		}
+		get _state() {
+			return this._stateInternal;
+		}
+		constructor() {
+			super();
+			this.#color_accessor_storage = __runInitializers(this, _color_initializers, null);
+			this.#size_accessor_storage = (__runInitializers(this, _color_extraInitializers), __runInitializers(this, _size_initializers, isLean() ? "s" : "m"));
+			this._stateInternal = __runInitializers(this, _size_extraInitializers);
+			this._observer = new IntersectionController(this, {
+				target: null,
+				callback: (entries) => this._detectStickyState(entries[0])
+			});
+			this._state = "sticky";
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.slot ||= "sticky-bar";
+			this.startUpdate();
+			const container = this.closest("sbb-container");
+			if (container) this.toggleState("expanded", container.expanded);
+			if (this._intersector) this._observer.observe(this._intersector);
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this.internals.states.delete("initialized");
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			if (!this._intersector) {
+				this._intersector = this.shadowRoot.querySelector(".sbb-sticky-bar__intersector");
+				this._observer.observe(this._intersector);
+			}
+			this._observer.observe(this);
+		}
+		_isZeroAnimationDuration() {
+			return isZeroAnimationDuration(this, "--sbb-sticky-bar-slide-vertically-animation-duration");
+		}
+		_detectStickyState(entry) {
+			this.internals.states.add("initialized");
+			const isSticky = !entry.isIntersecting && entry.boundingClientRect.top > 0;
+			const intersectorRect = this._intersector?.getBoundingClientRect();
+			const stickyBarRect = this.shadowRoot.querySelector(".sbb-sticky-bar__wrapper").getBoundingClientRect();
+			this.toggleState("slide-vertically", isSticky && this._intersector && Math.abs(intersectorRect.bottom - stickyBarRect.bottom) > 30);
+			this.toggleState("sticking", isSticky);
+			this.completeUpdate();
+		}
+		/** Animates from normal content flow position to `position: sticky`. */
+		stick() {
+			if (this._state !== "unsticky" || !this._dispatchBeforeStickEvent()) return;
+			this._state = "sticking";
+			if (!this.internals.states.has("sticking") || this._isZeroAnimationDuration()) this._stickyCallback();
+		}
+		/** Animates `position: sticky` to normal content flow position. */
+		unstick() {
+			if (this._state !== "sticky" || !this._dispatchBeforeUnStickEvent()) return;
+			this._state = "unsticking";
+			if (!this.internals.states.has("sticking") || this._isZeroAnimationDuration()) this._unstickyCallback();
+		}
+		_stickyCallback() {
+			this._state = "sticky";
+			/** Emits when the animation from normal content flow to `position: sticky` ends. */
+			this.dispatchEvent(new Event("stick"));
+		}
+		_unstickyCallback() {
+			/** Emits when the animation from `position: sticky` to normal content flow ends. */
+			this.dispatchEvent(new Event("unstick"));
+			this._state = "unsticky";
+		}
+		_onAnimationEnd(event) {
+			if ((this._state === "sticking" || this._state === "sticky") && event.animationName === "slide-in") this._stickyCallback();
+			else if (this._state === "unsticking" && event.animationName === "slide-out") this._unstickyCallback();
+		}
+		_dispatchBeforeStickEvent() {
+			/** Emits when the animation from normal content flow to `position: sticky` starts. Can be canceled. */
+			return this.dispatchEvent(new Event("beforestick", { cancelable: true }));
+		}
+		_dispatchBeforeUnStickEvent() {
+			/** Emits when the animation from `position: sticky` to normal content flow starts. Can be canceled. */
+			return this.dispatchEvent(new Event("beforeunstick", { cancelable: true }));
+		}
+		render() {
+			return html`
+      <div class="sbb-sticky-bar__wrapper" @animationend=${this._onAnimationEnd}>
+        <div class="sbb-sticky-bar">
+          <slot></slot>
+        </div>
+      </div>
+      <div class="sbb-sticky-bar__intersector"></div>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbStickyBarElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sticky-bar.component-DxDHpEgX.js","names":[],"sources":["../../../src/elements/container/sticky-bar/sticky-bar.scss?lit&inline","../../../src/elements/container/sticky-bar/sticky-bar.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n$intersector-overlapping: 1px;\n\n// `:state(sticking)` v.s. `:state(state-sticky)`:\n// While `:state(sticking)` is representing whether the sticky bar is currently sticking (due scrolling),\n// the `:state(state-xy)` holds information whether the `position: sticky` is applied or not\n// but not considering the real sticking state.\n\n:host {\n  --sbb-sticky-bar-fade-in-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-5x)\n  );\n  --sbb-sticky-bar-fade-out-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-2x)\n  );\n  --sbb-sticky-bar-slide-vertically-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-4x)\n  );\n  --_sbb-sticky-bar-background-animation-duration: var(\n    --sbb-sticky-bar-fade-out-animation-duration\n  );\n\n  // Display contents needed to get the sticky bar sticky.\n  display: contents;\n}\n\n:host([size='s']) {\n  --sbb-sticky-bar-padding-block: var(--sbb-spacing-responsive-xxxs);\n}\n\n:host([size='m']) {\n  --sbb-sticky-bar-padding-block: var(--sbb-spacing-responsive-xs);\n}\n\n:host(:state(sticking):not(:state(state-unsticky))) {\n  --sbb-sticky-bar-sticky-background-color: var(\n    --sbb-container-background-color,\n    var(--sbb-background-color-1)\n  );\n  --_sbb-sticky-bar-intersector-background-color: var(--sbb-sticky-bar-sticky-background-color);\n  --_sbb-sticky-bar-background-animation-duration: var(--sbb-sticky-bar-fade-in-animation-duration);\n\n  @include sbb.if-forced-colors {\n    --_sbb-sticky-bar-forced-colors-border: var(--sbb-border-width-1x) solid CanvasText;\n  }\n}\n\n:host(:state(sticking):not(:state(state-unsticky))[color='white']) {\n  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-1);\n}\n\n:host(:state(sticking):not(:state(state-unsticky))[color='milk']) {\n  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-3);\n}\n\n:host(:state(sticking):not(:state(state-unsticky))[color='midnight']) {\n  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-1-negative);\n}\n\n:host(:state(sticking):not(:state(state-unsticky))[color='charcoal']) {\n  --sbb-sticky-bar-sticky-background-color: var(--sbb-background-color-2-negative);\n}\n\n:host(\n  :is(\n    :state(sticking):is(:state(slide-vertically), :state(state-sticking), :state(state-unsticking)),\n    :state(state-unsticky)\n  )\n) {\n  --_sbb-sticky-bar-background-animation-duration: 0s;\n}\n\n:host(\n  :state(sticking):is(\n    :state(slide-vertically):not(:state(state-unsticky), :state(state-unsticking)),\n    :state(state-sticking)\n  )\n) {\n  --sbb-sticky-bar-slide-vertically-animation-name: slide-in;\n}\n\n:host(:state(sticking):state(state-unsticking)) {\n  --sbb-sticky-bar-slide-vertically-animation-name: slide-out;\n}\n\n:host(:is(:not(:state(initialized)), :state(state-unsticky))) {\n  --sbb-sticky-bar-position: relative;\n}\n\n.sbb-sticky-bar__wrapper {\n  position: var(--sbb-sticky-bar-position);\n  inset-block-end: 0;\n  display: block;\n  z-index: var(--sbb-sticky-bar-z-index);\n\n  animation: {\n    name: var(--sbb-sticky-bar-slide-vertically-animation-name, unset);\n    duration: var(--sbb-sticky-bar-slide-vertically-animation-duration);\n    timing-function: var(--sbb-sticky-bar-slide-vertically-animation-easing);\n    delay: 0s;\n\n    // Fill mode needed to enable delay\n    fill-mode: backwards;\n  }\n\n  &::after,\n  &::before {\n    content: '';\n    inset: 0;\n    position: absolute;\n    display: block;\n    z-index: -1;\n  }\n\n  // Container background color (copying container)\n  &::before {\n    background-color: var(--sbb-container-background-color);\n\n    // Needed because there is no content and Firefox\n    // has troubles displaying correct padding when there is no content.\n    padding: 0 !important;\n\n    :host(:not(:state(expanded))) & {\n      @include sbb.page-spacing;\n    }\n  }\n\n  // Color and border radius when sticky\n  &::after {\n    background-color: var(--sbb-sticky-bar-sticky-background-color, transparent);\n    border-start-start-radius: var(--sbb-sticky-bar-border-radius);\n    border-start-end-radius: var(--sbb-sticky-bar-border-radius);\n    transition: background-color var(--_sbb-sticky-bar-background-animation-duration)\n      var(--sbb-sticky-bar-animation-easing);\n\n    // Display a border on high contrast mode.\n    border: var(--_sbb-sticky-bar-forced-colors-border, none);\n  }\n}\n\n.sbb-sticky-bar {\n  display: flex;\n  padding-block: var(--sbb-sticky-bar-padding-block);\n\n  // To push the .sbb-sticky-bar__intersector up without using absolute position we need a negative block margin.\n  margin-block-end: -$intersector-overlapping;\n\n  // Shadow with border radius and clipped shadow at the bottom\n  &::before {\n    content: '';\n    position: absolute;\n    inset: 0;\n    z-index: -1;\n    border-start-start-radius: var(--sbb-sticky-bar-border-radius);\n    border-start-end-radius: var(--sbb-sticky-bar-border-radius);\n    transition: box-shadow var(--_sbb-sticky-bar-background-animation-duration)\n      var(--sbb-sticky-bar-animation-easing);\n    clip-path: polygon(\n      -100% calc(-1 * var(--sbb-shadow-elevation-level-11-shadow-1-blur)),\n      150% calc(-1 * var(--sbb-shadow-elevation-level-11-shadow-1-blur)),\n      150% 100%,\n      -100% 100%\n    );\n\n    :host(:state(sticking):not(:state(state-unsticky))) & {\n      box-shadow: var(--sbb-box-shadow-level-11-soft);\n    }\n  }\n\n  :host(:not(:state(expanded))) & {\n    @include sbb.page-spacing;\n  }\n\n  :host(:state(expanded)) & {\n    @include sbb.page-spacing-expanded;\n  }\n}\n\n.sbb-sticky-bar__intersector {\n  // In order to make the intersection observer work properly on windows the intersector needs to have a defined height\n  height: $intersector-overlapping;\n\n  &::after {\n    content: '';\n    display: block;\n    position: absolute;\n    width: 100%;\n    height: calc(var(--sbb-sticky-bar-bottom-overlapping-height, 0) + $intersector-overlapping);\n    background-color: var(--_sbb-sticky-bar-intersector-background-color, transparent);\n    pointer-events: none;\n    transition: background-color var(--_sbb-sticky-bar-background-animation-duration)\n      var(--sbb-sticky-bar-animation-easing);\n  }\n}\n\n@keyframes slide-in {\n  from {\n    transform: translateY(100%);\n  }\n\n  to {\n    transform: translateY(0%);\n  }\n}\n\n@keyframes slide-out {\n  from {\n    transform: translateY(0%);\n  }\n\n  to {\n    transform: translateY(100%);\n  }\n}\n","import { IntersectionController } from '@lit-labs/observers/intersection-controller.js';\nimport { type CSSResultGroup, html, type PropertyValues, type TemplateResult } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbElement } from '../../core/base-elements.ts';\nimport { isLean, isZeroAnimationDuration } from '../../core/dom.ts';\nimport { SbbUpdateSchedulerMixin } from '../../core/mixins.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\n\nimport style from './sticky-bar.scss?lit&inline';\n\ntype StickyState = 'sticking' | 'sticky' | 'unsticking' | 'unsticky';\n\n/**\n * A container that sticks to the bottom of the page if slotted into `sbb-container`.\n *\n * @slot - Use the unnamed slot to add content to the sticky bar.\n * @cssprop [--sbb-sticky-bar-padding-block=var(--sbb-spacing-responsive-xs)] - Block padding of the sticky bar.\n * @cssprop [--sbb-sticky-bar-bottom-overlapping-height=0px] - Define an additional area where\n * the sticky bar overlaps the following content on the bottom.\n * This area becomes visible when the sticky bar transitions from sticky to the normal document flow.\n * @cssprop [--sbb-sticky-bar-z-index] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable.\n */\nexport class SbbStickyBarElement extends SbbUpdateSchedulerMixin(SbbElement) {\n  public static override readonly elementName: string = 'sbb-sticky-bar';\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n\n  public static readonly events = {\n    beforestick: 'beforestick',\n    stick: 'stick',\n    beforeunstick: 'beforeunstick',\n    unstick: 'unstick',\n  } as const;\n\n  /** Color of the container, like transparent, white etc. */\n  @property({ reflect: true }) public accessor color:\n    | 'white'\n    | 'milk'\n    | 'midnight'\n    | 'charcoal'\n    | null = null;\n\n  /**\n   * Size of the container.\n   * @default 'm' / 's' (lean)\n   */\n  @property({ reflect: true }) public accessor size: 'm' | 's' = isLean() ? 's' : 'm';\n\n  /** The state of the component. */\n  private set _state(state: StickyState) {\n    if (this._stateInternal) {\n      this.internals.states.delete(`state-${this._stateInternal}`);\n    }\n    this._stateInternal = state;\n    if (this._stateInternal) {\n      this.internals.states.add(`state-${this._stateInternal}`);\n    }\n  }\n  private get _state(): StickyState {\n    return this._stateInternal;\n  }\n  private _stateInternal!: StickyState;\n\n  private _intersector?: HTMLSpanElement;\n  private _observer = new IntersectionController(this, {\n    // Although `this` is observed, we have to postpone observing\n    // into firstUpdated() to achieve a correct initial state.\n    target: null,\n    callback: (entries) => this._detectStickyState(entries[0]),\n  });\n\n  public constructor() {\n    super();\n\n    this._state = 'sticky';\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.slot ||= 'sticky-bar';\n\n    // Sticky bar needs to be hidden until first observer callback\n    this.startUpdate();\n\n    const container = this.closest('sbb-container');\n    if (container) {\n      this.toggleState('expanded', container.expanded);\n    }\n    if (this._intersector) {\n      this._observer.observe(this._intersector);\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this.internals.states.delete('initialized');\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    if (!this._intersector) {\n      this._intersector = this.shadowRoot!.querySelector('.sbb-sticky-bar__intersector')!;\n      this._observer.observe(this._intersector);\n    }\n    this._observer.observe(this);\n  }\n\n  private _isZeroAnimationDuration(): boolean {\n    return isZeroAnimationDuration(this, '--sbb-sticky-bar-slide-vertically-animation-duration');\n  }\n\n  private _detectStickyState(entry: IntersectionObserverEntry): void {\n    this.internals.states.add('initialized');\n\n    const isSticky = !entry.isIntersecting && entry.boundingClientRect.top > 0;\n\n    // To optimize the visual perception of the sticky bar, we have certain cases (e.g. on page load)\n    // where we want the sticky bar to slide in from the bottom.\n    // To decide whether to slide in from the bottom up,\n    // we check how far away the sticky bar is from the intersector element. When scrolling fast, the\n    // difference can vary slightly. To account for this we add a height tolerance.\n    // This value was found by trial and error.\n    const intersectorRect = this._intersector?.getBoundingClientRect();\n    const stickyBarRect = this.shadowRoot!.querySelector(\n      '.sbb-sticky-bar__wrapper',\n    )!.getBoundingClientRect();\n    const HEIGHT_TOLERANCE = 30;\n\n    this.toggleState(\n      'slide-vertically',\n      isSticky &&\n        this._intersector &&\n        Math.abs(intersectorRect!.bottom - stickyBarRect.bottom) > HEIGHT_TOLERANCE,\n    );\n\n    // Toggling sticking has to be after slide-vertically (prevents background color transition)\n    this.toggleState('sticking', isSticky);\n\n    // Sticky bar needs to be hidden until first observer callback\n    this.completeUpdate();\n  }\n\n  /** Animates from normal content flow position to `position: sticky`. */\n  public stick(): void {\n    if (this._state !== 'unsticky' || !this._dispatchBeforeStickEvent()) {\n      return;\n    }\n\n    this._state = 'sticking';\n    if (!this.internals.states.has('sticking') || this._isZeroAnimationDuration()) {\n      this._stickyCallback();\n    }\n  }\n\n  /** Animates `position: sticky` to normal content flow position. */\n  public unstick(): void {\n    if (this._state !== 'sticky' || !this._dispatchBeforeUnStickEvent()) {\n      return;\n    }\n\n    this._state = 'unsticking';\n\n    if (!this.internals.states.has('sticking') || this._isZeroAnimationDuration()) {\n      this._unstickyCallback();\n    }\n  }\n\n  private _stickyCallback(): void {\n    this._state = 'sticky';\n\n    /** Emits when the animation from normal content flow to `position: sticky` ends. */\n    this.dispatchEvent(new Event('stick'));\n  }\n\n  private _unstickyCallback(): void {\n    /** Emits when the animation from `position: sticky` to normal content flow ends. */\n    this.dispatchEvent(new Event('unstick'));\n    this._state = 'unsticky';\n  }\n\n  private _onAnimationEnd(event: AnimationEvent): void {\n    if (\n      (this._state === 'sticking' || this._state === 'sticky') &&\n      event.animationName === 'slide-in'\n    ) {\n      this._stickyCallback();\n    } else if (this._state === 'unsticking' && event.animationName === 'slide-out') {\n      this._unstickyCallback();\n    }\n  }\n\n  private _dispatchBeforeStickEvent(): boolean {\n    /** Emits when the animation from normal content flow to `position: sticky` starts. Can be canceled. */\n    return this.dispatchEvent(new Event('beforestick', { cancelable: true }));\n  }\n\n  private _dispatchBeforeUnStickEvent(): boolean {\n    /** Emits when the animation from `position: sticky` to normal content flow starts. Can be canceled. */\n    return this.dispatchEvent(new Event('beforeunstick', { cancelable: true }));\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-sticky-bar__wrapper\" @animationend=${this._onAnimationEnd}>\n        <div class=\"sbb-sticky-bar\">\n          <slot></slot>\n        </div>\n      </div>\n      <div class=\"sbb-sticky-bar__intersector\"></div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-sticky-bar': SbbStickyBarElement;\n  }\n}\n"],"mappings":"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"}

package/development/styles-BlQUk9lF.js

@@ -0,0 +1,96 @@
+import { css } from "lit";
+//#region src/elements/sidebar/common/sidebar-container-common.scss?lit&inline
+var sidebar_container_common_default = css`:host {
+  position: absolute;
+  inset: 0;
+}`;
+//#endregion
+//#region src/elements/sidebar/common/sidebar-content-common.scss?lit&inline
+var sidebar_content_common_default = css`:host {
+  position: relative;
+  display: block;
+  height: 100%;
+  overflow: auto;
+  outline-color: var(--sbb-focus-outline-color);
+}`;
+//#endregion
+//#region src/elements/sidebar/common/icon-sidebar-button-common.scss?lit&inline
+var icon_sidebar_button_common_default = css`:host {
+  display: block;
+  outline: none !important;
+  --sbb-icon-sidebar-button-transition-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-2x)
+  );
+  --sbb-icon-sidebar-button-transition-easing-function: var(--sbb-animation-easing);
+  --sbb-icon-sidebar-button-dimension: var(--sbb-size-element-m);
+  --sbb-icon-sidebar-button-border-radius: var(--sbb-border-radius-4x);
+  --sbb-icon-sidebar-button-color: var(--sbb-color-granite);
+  --sbb-icon-sidebar-button-color: light-dark(var(--sbb-color-granite), var(--sbb-color-graphite));
+  --sbb-icon-sidebar-button-current-color: var(--sbb-color-3);
+  --sbb-icon-sidebar-button-current-border-width: var(--sbb-border-width-3x);
+  --sbb-icon-sidebar-button-current-border-inset-block: var(--sbb-spacing-fixed-2x);
+  --sbb-icon-sidebar-button__current-border-inset-inline-start: 0;
+  --sbb-icon-sidebar-button__color: var(--sbb-icon-sidebar-button-color);
+}
+@media (forced-colors: active) {
+  :host {
+    --sbb-icon-sidebar-button-current-color: Highlight !important;
+  }
+}
+
+@media (forced-colors: active) {
+  :host(:is(:state(button),[state--button])) {
+    --sbb-icon-sidebar-button-color: ButtonText !important;
+  }
+}
+
+@media (forced-colors: active) {
+  :host(:is(:state(link),[state--link])) {
+    --sbb-icon-sidebar-button-color: LinkText !important;
+  }
+}
+
+@media (any-hover: hover) {
+  :host(:not(:active, :is(:state(active),[state--active])):hover) {
+    --sbb-icon-sidebar-button__hover-shift: 0.0625rem;
+    --sbb-icon-sidebar-button__cursor: var(--sbb-cursor-pointer);
+  }
+}
+
+.sbb-action-base {
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  height: var(--sbb-icon-sidebar-button-dimension);
+  padding-block: 0 calc(2 * var(--sbb-icon-sidebar-button__hover-shift, 0rem));
+  color: var(--sbb-icon-sidebar-button__color);
+  border-radius: var(--sbb-icon-sidebar-button-border-radius);
+  cursor: var(--sbb-icon-sidebar-button__cursor);
+  user-select: none;
+  transition-duration: var(--sbb-icon-sidebar-button-transition-duration);
+  transition-timing-function: var(--sbb-icon-sidebar-button-transition-easing-function);
+  transition-property: color, padding;
+}
+:host(.sbb-active) .sbb-action-base {
+  color: var(--sbb-icon-sidebar-button-current-color);
+}
+:host(.sbb-active) .sbb-action-base::before {
+  content: "";
+  display: block;
+  position: absolute;
+  inset-block: var(--sbb-icon-sidebar-button-current-border-inset-block);
+  inset-inline: var(--sbb-icon-sidebar-button__current-border-inset-inline-start) 0;
+  border-inline-start: var(--sbb-icon-sidebar-button-current-border-width) solid currentcolor;
+}
+:host(:focus-visible) .sbb-action-base, .sbb-action-base:focus-visible {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+  outline-offset: calc(-1 * var(--sbb-focus-outline-width) - 0.3125rem);
+}`;
+//#endregion
+export { sidebar_content_common_default as n, sidebar_container_common_default as r, icon_sidebar_button_common_default as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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