@sbb-esta/lyne-elements 1.14.0 → 1.15.0

package/development/container/sticky-bar.js

@@ -7,9 +7,11 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 import { __runInitializers, __esDecorate } from "tslib";
 import { IntersectionController } from "@lit-labs/observers/intersection-controller.js";
-import { css, html, LitElement } from "lit";
+import { css, LitElement, html } from "lit";
 import { customElement, property } from "lit/decorators.js";
 import { hostAttributes } from "../core/decorators.js";
+import { EventEmitter } from "../core/eventing.js";
+import { SbbUpdateSchedulerMixin } from "../core/mixins.js";
 const style = css`*,
 ::before,
 ::after {
@@ -17,7 +19,10 @@ const style = css`*,
 }
 
 :host {
+  --sbb-sticky-bar-position: sticky;
   --sbb-sticky-bar-padding-block: var(--sbb-spacing-responsive-xs);
+  --sbb-sticky-bar-border-radius: var(--sbb-border-radius-8x);
+  --sbb-sticky-bar-animation-easing: var(--sbb-animation-easing);
   --sbb-sticky-bar-fade-in-animation-duration: var(
     --sbb-disable-animation-zero-time,
     var(--sbb-animation-duration-5x)
@@ -26,31 +31,71 @@ const style = css`*,
     --sbb-disable-animation-zero-time,
     var(--sbb-animation-duration-2x)
   );
-  --sbb-sticky-bar-animation-easing: var(--sbb-animation-easing);
-  --sbb-sticky-bar-border-radius: var(--sbb-border-radius-8x);
+  --sbb-sticky-bar-slide-vertically-animation-duration: var(
+    --sbb-disable-animation-zero-duration,
+    var(--sbb-animation-duration-4x)
+  );
+  --sbb-sticky-bar-slide-vertically-animation-easing: ease-out;
+  --sbb-sticky-bar-slide-vertically-animation-delay: 0s;
+  --sbb-sticky-bar-slide-vertically-animation-name: unset;
+  --_sbb-sticky-bar-background-animation-duration: var(
+    --sbb-sticky-bar-fade-out-animation-duration
+  );
+  --_sbb-sticky-bar-intersector-background-color: transparent;
+  --_sbb-sticky-bar-forced-colors-border: none;
   display: contents;
 }
 
-:host([data-sticking]) {
+:host([data-sticking]:not([data-state=unsticky])) {
   --sbb-sticky-bar-sticky-background-color: var(
     --sbb-container-background-color,
     var(--sbb-color-white)
   );
+  --_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([data-sticking]:not([data-state=unsticky])) {
+    --_sbb-sticky-bar-forced-colors-border: var(--sbb-border-width-1x) solid CanvasText;
+  }
 }
 
-:host([data-sticking][color=white]) {
+:host([data-sticking]:not([data-state=unsticky])[color=white]) {
   --sbb-sticky-bar-sticky-background-color: var(--sbb-color-white);
 }
 
-:host([data-sticking][color=milk]) {
+:host([data-sticking]:not([data-state=unsticky])[color=milk]) {
   --sbb-sticky-bar-sticky-background-color: var(--sbb-color-milk);
 }
 
+:host(:is([data-sticking]:is([data-slide-vertically], [data-state=sticking], [data-state=unsticking]),
+[data-state=unsticky])) {
+  --_sbb-sticky-bar-background-animation-duration: 0s;
+}
+
+:host([data-sticking]:is([data-slide-vertically]:not([data-state=unsticky], [data-state=unsticking]),
+[data-state=sticking])) {
+  --sbb-sticky-bar-slide-vertically-animation-name: slide-in;
+}
+
+:host([data-sticking][data-state=unsticking]) {
+  --sbb-sticky-bar-slide-vertically-animation-name: slide-out;
+}
+
+:host(:is(:not([data-initialized]), [data-state=unsticky])) {
+  --sbb-sticky-bar-position: relative;
+}
+
 .sbb-sticky-bar__wrapper {
-  position: sticky;
+  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);
+  animation-duration: var(--sbb-sticky-bar-slide-vertically-animation-duration);
+  animation-timing-function: var(--sbb-sticky-bar-slide-vertically-animation-easing);
+  animation-delay: var(--sbb-sticky-bar-slide-vertically-animation-delay);
+  animation-fill-mode: backwards;
 }
 .sbb-sticky-bar__wrapper::after, .sbb-sticky-bar__wrapper::before {
   content: "";
@@ -75,18 +120,10 @@ const style = css`*,
 }
 .sbb-sticky-bar__wrapper::after {
   background-color: var(--sbb-sticky-bar-sticky-background-color, transparent);
-  transition: background-color var(--sbb-sticky-bar-fade-out-animation-duration) var(--sbb-sticky-bar-animation-easing);
   border-start-start-radius: var(--sbb-sticky-bar-border-radius);
   border-start-end-radius: var(--sbb-sticky-bar-border-radius);
-}
-:host([data-sticking]) .sbb-sticky-bar__wrapper::after {
-  transition-duration: var(--sbb-sticky-bar-fade-in-animation-duration);
-}
-@media (forced-colors: active) {
-  :host([data-sticking]) .sbb-sticky-bar__wrapper::after {
-    border-block-start: var(--sbb-border-width-1x) solid CanvasText;
-    border-radius: 0;
-  }
+  transition: background-color var(--_sbb-sticky-bar-background-animation-duration) var(--sbb-sticky-bar-animation-easing);
+  border: var(--_sbb-sticky-bar-forced-colors-border);
 }
 
 .sbb-sticky-bar {
@@ -101,12 +138,11 @@ const style = css`*,
   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-fade-out-animation-duration) var(--sbb-sticky-bar-animation-easing);
+  transition: box-shadow var(--_sbb-sticky-bar-background-animation-duration) var(--sbb-sticky-bar-animation-easing);
   clip-path: polygon(-50% calc(-1 * var(--sbb-shadow-elevation-level-11-shadow-1-blur)), 150% calc(-1 * var(--sbb-shadow-elevation-level-11-shadow-1-blur)), 150% 50%, -50% 50%);
 }
-:host([data-sticking]) .sbb-sticky-bar::before {
+:host([data-sticking]:not([data-state=unsticky])) .sbb-sticky-bar::before {
   box-shadow: var(--sbb-shadow-elevation-level-11-shadow-2-offset-x) var(--sbb-shadow-elevation-level-11-shadow-2-offset-y) var(--sbb-shadow-elevation-level-11-shadow-2-blur) var(--sbb-shadow-elevation-level-11-shadow-2-spread) var(--sbb-shadow-elevation-level-11-soft-2-color), var(--sbb-shadow-elevation-level-11-shadow-1-offset-x) var(--sbb-shadow-elevation-level-11-shadow-1-offset-y) var(--sbb-shadow-elevation-level-11-shadow-1-blur) var(--sbb-shadow-elevation-level-11-shadow-1-spread) var(--sbb-shadow-elevation-level-11-soft-1-color);
-  transition-duration: var(--sbb-sticky-bar-fade-in-animation-duration);
 }
 :host(:not([data-expanded])) .sbb-sticky-bar {
   padding-inline: var(--sbb-layout-base-offset-responsive);
@@ -131,13 +167,26 @@ const style = css`*,
   position: absolute;
   width: 100%;
   height: calc(var(--sbb-sticky-bar-bottom-overlapping-height, 0) + 1px);
-  background-color: transparent;
+  background-color: var(--_sbb-sticky-bar-intersector-background-color);
   pointer-events: none;
-  transition: background-color var(--sbb-sticky-bar-fade-out-animation-duration) var(--sbb-sticky-bar-animation-easing);
+  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%);
+  }
 }
-:host([data-sticking]) .sbb-sticky-bar__intersector::after {
-  transition-duration: var(--sbb-sticky-bar-fade-in-animation-duration);
-  background-color: var(--sbb-sticky-bar-sticky-background-color);
+@keyframes slide-out {
+  from {
+    transform: translateY(0%);
+  }
+  to {
+    transform: translateY(100%);
+  }
 }`;
 let SbbStickyBarElement = (() => {
   var _color_accessor_storage, _a;
@@ -147,21 +196,24 @@ let SbbStickyBarElement = (() => {
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
-  let _classSuper = LitElement;
+  let _classSuper = SbbUpdateSchedulerMixin(LitElement);
   let _color_decorators;
   let _color_initializers = [];
   let _color_extraInitializers = [];
-  _a = class extends _classSuper {
+  var SbbStickyBarElement2 = (_a = class extends _classSuper {
     constructor() {
       super(...arguments);
       __privateAdd(this, _color_accessor_storage);
       __privateSet(this, _color_accessor_storage, __runInitializers(this, _color_initializers, null));
-      this._intersector = __runInitializers(this, _color_extraInitializers);
+      this._willStick = (__runInitializers(this, _color_extraInitializers), new EventEmitter(this, SbbStickyBarElement2.events.willStick));
+      this._didStick = new EventEmitter(this, SbbStickyBarElement2.events.didStick);
+      this._willUnstick = new EventEmitter(this, SbbStickyBarElement2.events.willUnstick);
+      this._didUnstick = new EventEmitter(this, SbbStickyBarElement2.events.didUnstick);
       this._observer = new IntersectionController(this, {
         // Although `this` is observed, we have to postpone observing
         // into firstUpdated() to achieve a correct initial state.
         target: null,
-        callback: (entries) => this._toggleShadowVisibility(entries[0])
+        callback: (entries) => this._detectStickyState(entries[0])
       });
     }
     /** Color of the container, like transparent, white etc. */
@@ -171,8 +223,17 @@ let SbbStickyBarElement = (() => {
     set color(value) {
       __privateSet(this, _color_accessor_storage, value);
     }
+    /** The state of the component. */
+    set _state(state) {
+      this.setAttribute("data-state", state);
+    }
+    get _state() {
+      return this.getAttribute("data-state");
+    }
     connectedCallback() {
       super.connectedCallback();
+      this._state = "sticky";
+      this.startUpdate();
       const container = this.closest("sbb-container");
       if (container) {
         this.toggleAttribute("data-expanded", container.expanded);
@@ -181,6 +242,10 @@ let SbbStickyBarElement = (() => {
         this._observer.observe(this._intersector);
       }
     }
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this.toggleAttribute("data-initialized", false);
+    }
     firstUpdated(changedProperties) {
       super.firstUpdated(changedProperties);
       if (!this._intersector) {
@@ -189,12 +254,55 @@ let SbbStickyBarElement = (() => {
       }
       this._observer.observe(this);
     }
-    _toggleShadowVisibility(entry) {
-      this.toggleAttribute("data-sticking", !entry.isIntersecting && entry.boundingClientRect.top > 0);
+    _detectStickyState(entry) {
+      var _a2;
+      this.toggleAttribute("data-initialized", true);
+      const isSticky = !entry.isIntersecting && entry.boundingClientRect.top > 0;
+      const intersectorRect = (_a2 = this._intersector) == null ? void 0 : _a2.getBoundingClientRect();
+      const stickyBarRect = this.shadowRoot.querySelector(".sbb-sticky-bar__wrapper").getBoundingClientRect();
+      const HEIGHT_TOLERANCE = 30;
+      this.toggleAttribute("data-slide-vertically", isSticky && this._intersector && Math.abs(intersectorRect.bottom - stickyBarRect.bottom) > HEIGHT_TOLERANCE);
+      this.toggleAttribute("data-sticking", isSticky);
+      this.completeUpdate();
+    }
+    /** Animates from normal content flow position to `position: sticky`. */
+    stick() {
+      if (this._state !== "unsticky" || !this._willStick.emit()) {
+        return;
+      }
+      this._state = "sticking";
+      if (!this.hasAttribute("data-sticking")) {
+        this._stickyCallback();
+      }
+    }
+    /** Animates `position: sticky` to normal content flow position. */
+    unstick() {
+      if (this._state !== "sticky" || !this._willUnstick.emit()) {
+        return;
+      }
+      this._state = "unsticking";
+      if (!this.hasAttribute("data-sticking")) {
+        this._unstickyCallback();
+      }
+    }
+    _stickyCallback() {
+      this._state = "sticky";
+      this._didStick.emit();
+    }
+    _unstickyCallback() {
+      this._didUnstick.emit();
+      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();
+      }
     }
     render() {
       return html`
-      <div class="sbb-sticky-bar__wrapper">
+      <div class="sbb-sticky-bar__wrapper" @animationend=${this._onAnimationEnd}>
         <div class="sbb-sticky-bar">
           <slot></slot>
         </div>
@@ -209,12 +317,17 @@ let SbbStickyBarElement = (() => {
       obj.color = value;
     } }, metadata: _metadata }, _color_initializers, _color_extraInitializers);
     __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-    _classThis = _classDescriptor.value;
+    SbbStickyBarElement2 = _classThis = _classDescriptor.value;
     if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-  })(), _a.styles = style, __runInitializers(_classThis, _classExtraInitializers), _a;
-  return _classThis;
+  })(), _a.styles = style, _a.events = {
+    willStick: "willStick",
+    didStick: "didStick",
+    willUnstick: "willUnstick",
+    didUnstick: "didUnstick"
+  }, __runInitializers(_classThis, _classExtraInitializers), _a);
+  return SbbStickyBarElement2 = _classThis;
 })();
 export {
   SbbStickyBarElement
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sticky-bar.js","sources":["../../../../src/elements/container/sticky-bar/sticky-bar.ts"],"sourcesContent":["import { IntersectionController } from '@lit-labs/observers/intersection-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  LitElement,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\n\nimport { hostAttributes } from '../../core/decorators.js';\nimport { EventEmitter } from '../../core/eventing.js';\nimport { SbbUpdateSchedulerMixin } from '../../core/mixins.js';\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 * @event {CustomEvent<void>} willStick - Emits when the animation from normal content flow to `position: sticky` starts. Can be canceled.\n * @event {CustomEvent<void>} didStick - Emits when the animation from normal content flow to `position: sticky` ends.\n * @event {CustomEvent<void>} willUnstick - Emits when the animation from `position: sticky` to normal content flow starts. Can be canceled.\n * @event {CustomEvent<void>} didUnstick - Emits when the animation from `position: sticky` to normal content flow ends.\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\n@customElement('sbb-sticky-bar')\n@hostAttributes({\n  slot: 'sticky-bar',\n})\nclass SbbStickyBarElement extends SbbUpdateSchedulerMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n\n  public static readonly events = {\n    willStick: 'willStick',\n    didStick: 'didStick',\n    willUnstick: 'willUnstick',\n    didUnstick: 'didUnstick',\n  } as const;\n\n  /** Color of the container, like transparent, white etc. */\n  @property({ reflect: true }) public accessor color: 'white' | 'milk' | null = null;\n\n  /** The state of the component. */\n  private set _state(state: StickyState) {\n    this.setAttribute('data-state', state);\n  }\n  private get _state(): StickyState {\n    return this.getAttribute('data-state') as StickyState;\n  }\n\n  private _willStick: EventEmitter = new EventEmitter(this, SbbStickyBarElement.events.willStick);\n  private _didStick: EventEmitter = new EventEmitter(this, SbbStickyBarElement.events.didStick);\n  private _willUnstick: EventEmitter = new EventEmitter(\n    this,\n    SbbStickyBarElement.events.willUnstick,\n  );\n  private _didUnstick: EventEmitter = new EventEmitter(this, SbbStickyBarElement.events.didUnstick);\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 override connectedCallback(): void {\n    super.connectedCallback();\n    this._state = 'sticky';\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.toggleAttribute('data-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\n    this.toggleAttribute('data-initialized', false);\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 _detectStickyState(entry: IntersectionObserverEntry): void {\n    this.toggleAttribute('data-initialized', true);\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.toggleAttribute(\n      'data-slide-vertically',\n      isSticky &&\n        this._intersector &&\n        Math.abs(intersectorRect!.bottom - stickyBarRect.bottom) > HEIGHT_TOLERANCE,\n    );\n\n    // Toggling data-sticking has to be after data-slide-vertically (prevents background color transition)\n    this.toggleAttribute('data-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._willStick.emit()) {\n      return;\n    }\n\n    this._state = 'sticking';\n    if (!this.hasAttribute('data-sticking')) {\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._willUnstick.emit()) {\n      return;\n    }\n\n    this._state = 'unsticking';\n\n    if (!this.hasAttribute('data-sticking')) {\n      this._unstickyCallback();\n    }\n  }\n\n  private _stickyCallback(): void {\n    this._state = 'sticky';\n    this._didStick.emit();\n  }\n\n  private _unstickyCallback(): void {\n    this._didUnstick.emit();\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  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"],"names":["SbbStickyBarElement","_a"],"mappings":"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"}

package/development/core/controllers/media-matchers-controller.d.ts

@@ -0,0 +1,32 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+export declare const SbbMediaQueryForcedColors = "(forced-colors: active)";
+export declare const SbbMediaQueryHover = "(any-hover: hover)";
+export declare const SbbMediaQueryPointerCoarse = "(pointer: coarse)";
+export declare const SbbMediaQueryBreakpointMediumAndAbove: string;
+export declare const SbbMediaQueryBreakpointSmallAndBelow: string;
+/**
+ * A callback, which is invoked when the associated media query match
+ * status changes.
+ */
+export type SbbMediaMatcherHandler = (matches: boolean) => void;
+/**
+ * This controller allows listening to media query changes.
+ *
+ * @example
+ * new SbbMediaMatcherController(this, {
+ *   [SbbForcedColorsQuery]: (matches) => doSomething(matches),
+ * })
+ */
+export declare class SbbMediaMatcherController implements ReactiveController {
+    private _queries;
+    constructor(host: ReactiveControllerHost, _queries: Record<string, SbbMediaMatcherHandler>);
+    /**
+     * Returns whether the given query matches. Returns null with SSR.
+     * @param query The query to check against.
+     * @returns Whether the query matches or null with SSR.
+     */
+    matches(query: string): boolean | null;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+//# sourceMappingURL=media-matchers-controller.d.ts.map

package/development/core/controllers/media-matchers-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-matchers-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/media-matchers-controller.ts"],"names":[],"mappings":"AAKA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAKrF,eAAO,MAAM,yBAAyB,4BAA4B,CAAC;AACnE,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AACvD,eAAO,MAAM,0BAA0B,sBAAsB,CAAC;AAC9D,eAAO,MAAM,qCAAqC,QAAuD,CAAC;AAC1G,eAAO,MAAM,oCAAoC,QAAsD,CAAC;AAGxG;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AAehE;;;;;;;GAOG;AACH,qBAAa,yBAA0B,YAAW,kBAAkB;IAGhE,OAAO,CAAC,QAAQ;gBADhB,IAAI,EAAE,sBAAsB,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC;IAK1D;;;;OAIG;IACI,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI;IAYtC,aAAa,IAAI,IAAI;IAoBrB,gBAAgB,IAAI,IAAI;CAWhC"}

package/development/core/controllers.d.ts

@@ -1,5 +1,6 @@
 export * from './controllers/connected-abort-controller.js';
 export * from './controllers/inert-controller.js';
 export * from './controllers/language-controller.js';
+export * from './controllers/media-matchers-controller.js';
 export * from './controllers/slot-state-controller.js';
 //# sourceMappingURL=controllers.d.ts.map

package/development/core/controllers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/controllers.ts"],"names":[],"mappings":"AAAA,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC"}
+{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/controllers.ts"],"names":[],"mappings":"AAAA,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC"}

package/development/core/controllers.js

@@ -1,5 +1,6 @@
 import { isServer } from "lit";
 import { readConfig } from "./config.js";
+import { S as SbbTypoScaleDefault, g as SbbBreakpointMediumMin, f as SbbBreakpointSmallMax } from "../sbb-tokens-BdGhUJjM.js";
 class SbbConnectedAbortController {
   get signal() {
     var _a;
@@ -167,6 +168,63 @@ _SbbLanguageController._observerConfig = {
   attributeOldValue: true
 };
 let SbbLanguageController = _SbbLanguageController;
+const pxToRem = (px) => px / SbbTypoScaleDefault;
+const SbbMediaQueryForcedColors = "(forced-colors: active)";
+const SbbMediaQueryHover = "(any-hover: hover)";
+const SbbMediaQueryPointerCoarse = "(pointer: coarse)";
+const SbbMediaQueryBreakpointMediumAndAbove = `(min-width: ${pxToRem(SbbBreakpointMediumMin)}rem)`;
+const SbbMediaQueryBreakpointSmallAndBelow = `(max-width: ${pxToRem(SbbBreakpointSmallMax)}rem)`;
+const mediaQueryRegistry = /* @__PURE__ */ new Map();
+class SbbMediaMatcherController {
+  constructor(host, _queries) {
+    this._queries = _queries;
+    host.addController(this);
+  }
+  /**
+   * Returns whether the given query matches. Returns null with SSR.
+   * @param query The query to check against.
+   * @returns Whether the query matches or null with SSR.
+   */
+  matches(query) {
+    if (isServer) {
+      return null;
+    }
+    const mediaQuery = mediaQueryRegistry.get(query);
+    if (mediaQuery) {
+      return mediaQuery.mediaQueryList.matches;
+    } else {
+      return matchMedia(query).matches;
+    }
+  }
+  hostConnected() {
+    if (isServer) {
+      return;
+    }
+    for (const [query, handler] of Object.entries(this._queries)) {
+      const mediaQuery = mediaQueryRegistry.get(query);
+      if (mediaQuery) {
+        mediaQuery.handlers.add(handler);
+      } else {
+        const mediaQueryList = matchMedia(query);
+        const handlers = /* @__PURE__ */ new Set([handler]);
+        const eventHandler = (e) => handlers.forEach((h) => h(e.matches));
+        mediaQueryList.addEventListener("change", eventHandler);
+        mediaQueryRegistry.set(query, { mediaQueryList, handlers, eventHandler });
+      }
+    }
+  }
+  hostDisconnected() {
+    for (const [query, handler] of Object.entries(this._queries)) {
+      const mediaQuery = mediaQueryRegistry.get(query);
+      if (mediaQuery) {
+        mediaQuery.handlers.delete(handler);
+        if (!mediaQuery.handlers.size) {
+          mediaQueryRegistry.delete(query);
+        }
+      }
+    }
+  }
+}
 class SbbSlotStateController {
   constructor(_host, _onChangeCallback = null) {
     this._host = _host;
@@ -215,6 +273,12 @@ export {
   SbbConnectedAbortController,
   SbbInertController,
   SbbLanguageController,
+  SbbMediaMatcherController,
+  SbbMediaQueryBreakpointMediumAndAbove,
+  SbbMediaQueryBreakpointSmallAndBelow,
+  SbbMediaQueryForcedColors,
+  SbbMediaQueryHover,
+  SbbMediaQueryPointerCoarse,
   SbbSlotStateController
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"controllers.js","sources":["../../../../src/elements/core/controllers/connected-abort-controller.ts","../../../../src/elements/core/controllers/inert-controller.ts","../../../../src/elements/core/controllers/language-controller.ts","../../../../src/elements/core/controllers/slot-state-controller.ts"],"sourcesContent":["import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nexport class SbbConnectedAbortController implements ReactiveController {\n  private _abortController?: AbortController = new AbortController();\n\n  public get signal(): AbortSignal | undefined {\n    return this._abortController?.signal;\n  }\n\n  public constructor(private _host: ReactiveControllerHost) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    if (!this._abortController) {\n      this._abortController = new AbortController();\n    }\n  }\n\n  public hostDisconnected(): void {\n    this._abortController?.abort();\n    this._abortController = undefined;\n  }\n}\n","import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nimport type { SbbOpenCloseBaseElement } from '../base-elements/open-close-base-element.js';\n\nconst IGNORED_ELEMENTS = ['script', 'head', 'template', 'style'];\nconst inertElements = new Set<HTMLElement>();\nconst inertOverlays = new Set<HTMLElement>();\n\nexport class SbbInertController implements ReactiveController {\n  public constructor(\n    private _host: ReactiveControllerHost & SbbOpenCloseBaseElement,\n    private _inertElements = inertElements,\n    private _inertOverlays = inertOverlays,\n  ) {\n    this._host.addController?.(this);\n  }\n\n  public hostConnected(): void {\n    if (this._host.isOpen) {\n      this.activate();\n    }\n  }\n\n  public hostDisconnected(): void {\n    if (this._inertOverlays.has(this._host)) {\n      this.deactivate();\n    }\n  }\n\n  /** Applies inert state to every other element on the page except the overlay. */\n  public activate(): void {\n    // Remove inert state from previous opened overlay\n    if (this._inertOverlays.size) {\n      this._removeInertAttributes();\n    }\n\n    this._inertOverlays.add(this._host);\n    this._addInertAttributes();\n  }\n\n  /** Removes inert state. */\n  public deactivate(): void {\n    if (this._currentOverlay() !== this._host) {\n      // If e.g. a component gets disconnected, it could be that it is not the top most.\n      // In this case, we can directly remove it, as there is currently no inert state applied.\n      if (this._inertOverlays.has(this._host)) {\n        this._inertOverlays.delete(this._host);\n      } else if (import.meta.env.DEV) {\n        console.warn(\n          'Trying to remove inert state of an overlay which never had an applied inert state.',\n          this._host,\n        );\n      }\n\n      return;\n    }\n\n    this._removeInertAttributes();\n    this._inertOverlays.delete(this._host);\n\n    // If there is as previous opened overlay, set its inert state again.\n    if (this._inertOverlays.size) {\n      this._addInertAttributes();\n    }\n  }\n\n  private _currentOverlay(): HTMLElement | null {\n    return [...this._inertOverlays].pop() ?? null;\n  }\n\n  private _removeInertAttributes(): void {\n    this._inertElements.forEach((element: HTMLElement): void => {\n      if (!element) {\n        return;\n      }\n\n      if (element.hasAttribute('data-sbb-inert')) {\n        element.inert = false;\n        element.removeAttribute('data-sbb-inert');\n      }\n\n      if (element.hasAttribute('data-sbb-aria-hidden')) {\n        element.removeAttribute('aria-hidden');\n        element.removeAttribute('data-sbb-aria-hidden');\n      }\n    });\n    this._inertElements.clear();\n  }\n\n  private _addInertAttributes(): void {\n    let element: Element | null = this._currentOverlay();\n\n    while (element !== document.documentElement && element !== null) {\n      Array.from((element?.parentElement ?? element?.getRootNode())?.childNodes ?? [])\n        .filter(\n          (child): child is HTMLElement =>\n            child !== element &&\n            child instanceof window.HTMLElement &&\n            !IGNORED_ELEMENTS.includes(child.localName),\n        )\n        .forEach((element) => {\n          this._inertElements.add(element);\n\n          if (!element.inert) {\n            element.inert = true;\n            element.toggleAttribute('data-sbb-inert', true);\n          }\n\n          if (!element.hasAttribute('aria-hidden')) {\n            element.setAttribute('aria-hidden', 'true');\n            element.toggleAttribute('data-sbb-aria-hidden', true);\n          }\n        });\n\n      // We need to pierce through Shadow DOM boundary\n      element = element?.parentElement ?? (element?.getRootNode() as ShadowRoot)?.host ?? null;\n    }\n  }\n}\n","import { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nimport { readConfig } from '../config.js';\n\n/**\n * The LanguageController is a reactive controller that observes the \"lang\" attribute\n * of the <html> tag.\n * On change of the \"lang\" attribute, it will request an update of connected\n * components.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang\n */\nexport class SbbLanguageController implements ReactiveController {\n  private static readonly _defaultLanguage = 'en';\n  private static readonly _supportedLocales = ['en', 'de', 'fr', 'it'];\n\n  /** A set of connected components that should be notified on language change. */\n  private static readonly _listeners = new Set<SbbLanguageController>();\n\n  /** MutationObserver that observes the \"lang\" attribute of the <html> element. */\n  private static readonly _observer = !isServer\n    ? new MutationObserver((mutations) => {\n        if (mutations[0].oldValue !== document.documentElement.getAttribute('lang')) {\n          SbbLanguageController._listeners.forEach((l) => l._callHandlers());\n        }\n      })\n    : null;\n  private static readonly _observerConfig = {\n    attributeFilter: ['lang'],\n    attributeOldValue: true,\n  };\n\n  /** Get the current language. */\n  public static get current(): string {\n    const language =\n      (readConfig().language ??\n        (isServer\n          ? SbbLanguageController._defaultLanguage\n          : document.documentElement.getAttribute('lang'))) ||\n      SbbLanguageController._defaultLanguage;\n\n    // Support e.g. cases like `de-ch`.\n    const langAttributeNormalized = language.split('-')[0];\n    return SbbLanguageController._supportedLocales.includes(langAttributeNormalized)\n      ? langAttributeNormalized\n      : SbbLanguageController._defaultLanguage;\n  }\n\n  /** Get the current language. */\n  public get current(): string {\n    return SbbLanguageController.current;\n  }\n\n  private _previousLanguage?: string;\n  private _handlers: (() => void)[] = [];\n\n  public constructor(private _host: ReactiveControllerHost) {\n    this._host.addController(this);\n  }\n\n  /** Add a language change handler. */\n  public withHandler(handler: () => void): this {\n    // We use unshift here, to prepend additional handlers.\n    // This ensures that requestUpdate is called after the other handlers.\n    this._handlers.unshift(handler);\n    return this;\n  }\n\n  public hostConnected(): void {\n    if (isServer) {\n      return;\n    }\n    if (!SbbLanguageController._listeners.size) {\n      SbbLanguageController._observer!.observe(\n        document.documentElement,\n        SbbLanguageController._observerConfig,\n      );\n    }\n\n    SbbLanguageController._listeners.add(this);\n    if (this._previousLanguage !== this.current) {\n      this._callHandlers(this._previousLanguage !== undefined);\n    }\n  }\n\n  public hostDisconnected(): void {\n    if (isServer) {\n      return;\n    }\n    this._previousLanguage = this.current;\n    SbbLanguageController._listeners.delete(this);\n    if (!SbbLanguageController._listeners.size) {\n      SbbLanguageController._observer!.disconnect();\n    }\n  }\n\n  private _callHandlers(requestUpdate = true): void {\n    this._handlers.forEach((h) => h());\n    if (requestUpdate) {\n      this._host.requestUpdate();\n    }\n  }\n}\n","import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\n/**\n * This controller checks for slotted children. From these it generates\n * a list of used slot names (`unnamed` for children without a slot attribute)\n * and adds this to the `data-slot-names` attribute, as a space separated list.\n *\n * This allows CSS attribute selector to display/hide/configure a section\n * of the component as required (see [attr~=value] selector specifically).\n *\n * @example\n * .example {\n *   display: none;\n *\n *   :host([data-slot-names~=\"icon\"]) & {\n *     display: inline;\n *   }\n * }\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors\n */\nexport class SbbSlotStateController implements ReactiveController {\n  public readonly slots = new Set<string>();\n\n  public constructor(\n    private _host: ReactiveControllerHost & HTMLElement,\n    private _onChangeCallback: (() => void) | null = null,\n  ) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    // TODO: Check if this is really needed with SSR.\n    this._syncSlots(...this._host.querySelectorAll!('slot'));\n    this._host.shadowRoot?.addEventListener('slotchange', this._slotchangeHandler);\n  }\n\n  public hostDisconnected(): void {\n    this._host.shadowRoot?.removeEventListener('slotchange', this._slotchangeHandler);\n  }\n\n  // We avoid using AbortController here, as it would mean creating\n  // a new instance for every NamedSlotStateController instance.\n  private _slotchangeHandler = (event: Event): void => {\n    this._syncSlots(event.target as HTMLSlotElement);\n  };\n\n  private _syncSlots(...slots: HTMLSlotElement[]): void {\n    for (const slot of slots) {\n      const slotName = slot.name || 'unnamed';\n      // We want to check, whether an element is slotted or a text node with actual content.\n      if (slot.assignedNodes().some((n) => 'tagName' in n || n.textContent?.trim())) {\n        this.slots.add(slotName);\n      } else {\n        this.slots.delete(slotName);\n      }\n    }\n\n    const oldValue = this._host.getAttribute('data-slot-names');\n    const joinedSlotNames = [...this.slots].sort().join(' ');\n    if (!joinedSlotNames) {\n      this._host.removeAttribute('data-slot-names');\n    } else if (this._host.getAttribute('data-slot-names') !== joinedSlotNames) {\n      this._host.setAttribute('data-slot-names', joinedSlotNames);\n    }\n\n    if (joinedSlotNames !== oldValue) {\n      this._onChangeCallback?.();\n    }\n  }\n}\n"],"names":["element","_a"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"controllers.js","sources":["../../../../src/elements/core/controllers/connected-abort-controller.ts","../../../../src/elements/core/controllers/inert-controller.ts","../../../../src/elements/core/controllers/language-controller.ts","../../../../src/elements/core/controllers/media-matchers-controller.ts","../../../../src/elements/core/controllers/slot-state-controller.ts"],"sourcesContent":["import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nexport class SbbConnectedAbortController implements ReactiveController {\n  private _abortController?: AbortController = new AbortController();\n\n  public get signal(): AbortSignal | undefined {\n    return this._abortController?.signal;\n  }\n\n  public constructor(private _host: ReactiveControllerHost) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    if (!this._abortController) {\n      this._abortController = new AbortController();\n    }\n  }\n\n  public hostDisconnected(): void {\n    this._abortController?.abort();\n    this._abortController = undefined;\n  }\n}\n","import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nimport type { SbbOpenCloseBaseElement } from '../base-elements/open-close-base-element.js';\n\nconst IGNORED_ELEMENTS = ['script', 'head', 'template', 'style'];\nconst inertElements = new Set<HTMLElement>();\nconst inertOverlays = new Set<HTMLElement>();\n\nexport class SbbInertController implements ReactiveController {\n  public constructor(\n    private _host: ReactiveControllerHost & SbbOpenCloseBaseElement,\n    private _inertElements = inertElements,\n    private _inertOverlays = inertOverlays,\n  ) {\n    this._host.addController?.(this);\n  }\n\n  public hostConnected(): void {\n    if (this._host.isOpen) {\n      this.activate();\n    }\n  }\n\n  public hostDisconnected(): void {\n    if (this._inertOverlays.has(this._host)) {\n      this.deactivate();\n    }\n  }\n\n  /** Applies inert state to every other element on the page except the overlay. */\n  public activate(): void {\n    // Remove inert state from previous opened overlay\n    if (this._inertOverlays.size) {\n      this._removeInertAttributes();\n    }\n\n    this._inertOverlays.add(this._host);\n    this._addInertAttributes();\n  }\n\n  /** Removes inert state. */\n  public deactivate(): void {\n    if (this._currentOverlay() !== this._host) {\n      // If e.g. a component gets disconnected, it could be that it is not the top most.\n      // In this case, we can directly remove it, as there is currently no inert state applied.\n      if (this._inertOverlays.has(this._host)) {\n        this._inertOverlays.delete(this._host);\n      } else if (import.meta.env.DEV) {\n        console.warn(\n          'Trying to remove inert state of an overlay which never had an applied inert state.',\n          this._host,\n        );\n      }\n\n      return;\n    }\n\n    this._removeInertAttributes();\n    this._inertOverlays.delete(this._host);\n\n    // If there is as previous opened overlay, set its inert state again.\n    if (this._inertOverlays.size) {\n      this._addInertAttributes();\n    }\n  }\n\n  private _currentOverlay(): HTMLElement | null {\n    return [...this._inertOverlays].pop() ?? null;\n  }\n\n  private _removeInertAttributes(): void {\n    this._inertElements.forEach((element: HTMLElement): void => {\n      if (!element) {\n        return;\n      }\n\n      if (element.hasAttribute('data-sbb-inert')) {\n        element.inert = false;\n        element.removeAttribute('data-sbb-inert');\n      }\n\n      if (element.hasAttribute('data-sbb-aria-hidden')) {\n        element.removeAttribute('aria-hidden');\n        element.removeAttribute('data-sbb-aria-hidden');\n      }\n    });\n    this._inertElements.clear();\n  }\n\n  private _addInertAttributes(): void {\n    let element: Element | null = this._currentOverlay();\n\n    while (element !== document.documentElement && element !== null) {\n      Array.from((element?.parentElement ?? element?.getRootNode())?.childNodes ?? [])\n        .filter(\n          (child): child is HTMLElement =>\n            child !== element &&\n            child instanceof window.HTMLElement &&\n            !IGNORED_ELEMENTS.includes(child.localName),\n        )\n        .forEach((element) => {\n          this._inertElements.add(element);\n\n          if (!element.inert) {\n            element.inert = true;\n            element.toggleAttribute('data-sbb-inert', true);\n          }\n\n          if (!element.hasAttribute('aria-hidden')) {\n            element.setAttribute('aria-hidden', 'true');\n            element.toggleAttribute('data-sbb-aria-hidden', true);\n          }\n        });\n\n      // We need to pierce through Shadow DOM boundary\n      element = element?.parentElement ?? (element?.getRootNode() as ShadowRoot)?.host ?? null;\n    }\n  }\n}\n","import { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nimport { readConfig } from '../config.js';\n\n/**\n * The LanguageController is a reactive controller that observes the \"lang\" attribute\n * of the <html> tag.\n * On change of the \"lang\" attribute, it will request an update of connected\n * components.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang\n */\nexport class SbbLanguageController implements ReactiveController {\n  private static readonly _defaultLanguage = 'en';\n  private static readonly _supportedLocales = ['en', 'de', 'fr', 'it'];\n\n  /** A set of connected components that should be notified on language change. */\n  private static readonly _listeners = new Set<SbbLanguageController>();\n\n  /** MutationObserver that observes the \"lang\" attribute of the <html> element. */\n  private static readonly _observer = !isServer\n    ? new MutationObserver((mutations) => {\n        if (mutations[0].oldValue !== document.documentElement.getAttribute('lang')) {\n          SbbLanguageController._listeners.forEach((l) => l._callHandlers());\n        }\n      })\n    : null;\n  private static readonly _observerConfig = {\n    attributeFilter: ['lang'],\n    attributeOldValue: true,\n  };\n\n  /** Get the current language. */\n  public static get current(): string {\n    const language =\n      (readConfig().language ??\n        (isServer\n          ? SbbLanguageController._defaultLanguage\n          : document.documentElement.getAttribute('lang'))) ||\n      SbbLanguageController._defaultLanguage;\n\n    // Support e.g. cases like `de-ch`.\n    const langAttributeNormalized = language.split('-')[0];\n    return SbbLanguageController._supportedLocales.includes(langAttributeNormalized)\n      ? langAttributeNormalized\n      : SbbLanguageController._defaultLanguage;\n  }\n\n  /** Get the current language. */\n  public get current(): string {\n    return SbbLanguageController.current;\n  }\n\n  private _previousLanguage?: string;\n  private _handlers: (() => void)[] = [];\n\n  public constructor(private _host: ReactiveControllerHost) {\n    this._host.addController(this);\n  }\n\n  /** Add a language change handler. */\n  public withHandler(handler: () => void): this {\n    // We use unshift here, to prepend additional handlers.\n    // This ensures that requestUpdate is called after the other handlers.\n    this._handlers.unshift(handler);\n    return this;\n  }\n\n  public hostConnected(): void {\n    if (isServer) {\n      return;\n    }\n    if (!SbbLanguageController._listeners.size) {\n      SbbLanguageController._observer!.observe(\n        document.documentElement,\n        SbbLanguageController._observerConfig,\n      );\n    }\n\n    SbbLanguageController._listeners.add(this);\n    if (this._previousLanguage !== this.current) {\n      this._callHandlers(this._previousLanguage !== undefined);\n    }\n  }\n\n  public hostDisconnected(): void {\n    if (isServer) {\n      return;\n    }\n    this._previousLanguage = this.current;\n    SbbLanguageController._listeners.delete(this);\n    if (!SbbLanguageController._listeners.size) {\n      SbbLanguageController._observer!.disconnect();\n    }\n  }\n\n  private _callHandlers(requestUpdate = true): void {\n    this._handlers.forEach((h) => h());\n    if (requestUpdate) {\n      this._host.requestUpdate();\n    }\n  }\n}\n","import {\n  SbbBreakpointMediumMin,\n  SbbBreakpointSmallMax,\n  SbbTypoScaleDefault,\n} from '@sbb-esta/lyne-design-tokens';\nimport { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nconst pxToRem = (px: number): number => px / SbbTypoScaleDefault;\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport const SbbMediaQueryForcedColors = '(forced-colors: active)';\nexport const SbbMediaQueryHover = '(any-hover: hover)';\nexport const SbbMediaQueryPointerCoarse = '(pointer: coarse)';\nexport const SbbMediaQueryBreakpointMediumAndAbove = `(min-width: ${pxToRem(SbbBreakpointMediumMin)}rem)`;\nexport const SbbMediaQueryBreakpointSmallAndBelow = `(max-width: ${pxToRem(SbbBreakpointSmallMax)}rem)`;\n/* eslint-enable @typescript-eslint/naming-convention */\n\n/**\n * A callback, which is invoked when the associated media query match\n * status changes.\n */\nexport type SbbMediaMatcherHandler = (matches: boolean) => void;\n\ninterface MediaQueryEntry {\n  mediaQueryList: MediaQueryList;\n  eventHandler: (event: MediaQueryListEvent) => void;\n  handlers: Set<SbbMediaMatcherHandler>;\n}\n\n/**\n * We want to cache MediaQueryList instances and corresponding\n * event handlers, as a multitude of event handlers on global objects\n * can degrade performance with time.\n */\nconst mediaQueryRegistry = new Map<string, MediaQueryEntry>();\n\n/**\n * This controller allows listening to media query changes.\n *\n * @example\n * new SbbMediaMatcherController(this, {\n *   [SbbForcedColorsQuery]: (matches) => doSomething(matches),\n * })\n */\nexport class SbbMediaMatcherController implements ReactiveController {\n  public constructor(\n    host: ReactiveControllerHost,\n    private _queries: Record<string, SbbMediaMatcherHandler>,\n  ) {\n    host.addController(this);\n  }\n\n  /**\n   * Returns whether the given query matches. Returns null with SSR.\n   * @param query The query to check against.\n   * @returns Whether the query matches or null with SSR.\n   */\n  public matches(query: string): boolean | null {\n    if (isServer) {\n      return null;\n    }\n    const mediaQuery = mediaQueryRegistry.get(query);\n    if (mediaQuery) {\n      return mediaQuery.mediaQueryList.matches;\n    } else {\n      return matchMedia(query).matches;\n    }\n  }\n\n  public hostConnected(): void {\n    if (isServer) {\n      return;\n    }\n\n    for (const [query, handler] of Object.entries(this._queries)) {\n      const mediaQuery = mediaQueryRegistry.get(query);\n      if (mediaQuery) {\n        mediaQuery.handlers.add(handler);\n      } else {\n        const mediaQueryList = matchMedia(query);\n        const handlers = new Set([handler]);\n        const eventHandler = (e: MediaQueryListEvent): void =>\n          handlers.forEach((h) => h(e.matches));\n        mediaQueryList.addEventListener('change', eventHandler);\n        mediaQueryRegistry.set(query, { mediaQueryList, handlers, eventHandler });\n      }\n    }\n  }\n\n  public hostDisconnected(): void {\n    for (const [query, handler] of Object.entries(this._queries)) {\n      const mediaQuery = mediaQueryRegistry.get(query);\n      if (mediaQuery) {\n        mediaQuery.handlers.delete(handler);\n        if (!mediaQuery.handlers.size) {\n          mediaQueryRegistry.delete(query);\n        }\n      }\n    }\n  }\n}\n","import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\n/**\n * This controller checks for slotted children. From these it generates\n * a list of used slot names (`unnamed` for children without a slot attribute)\n * and adds this to the `data-slot-names` attribute, as a space separated list.\n *\n * This allows CSS attribute selector to display/hide/configure a section\n * of the component as required (see [attr~=value] selector specifically).\n *\n * @example\n * .example {\n *   display: none;\n *\n *   :host([data-slot-names~=\"icon\"]) & {\n *     display: inline;\n *   }\n * }\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors\n */\nexport class SbbSlotStateController implements ReactiveController {\n  public readonly slots = new Set<string>();\n\n  public constructor(\n    private _host: ReactiveControllerHost & HTMLElement,\n    private _onChangeCallback: (() => void) | null = null,\n  ) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    // TODO: Check if this is really needed with SSR.\n    this._syncSlots(...this._host.querySelectorAll!('slot'));\n    this._host.shadowRoot?.addEventListener('slotchange', this._slotchangeHandler);\n  }\n\n  public hostDisconnected(): void {\n    this._host.shadowRoot?.removeEventListener('slotchange', this._slotchangeHandler);\n  }\n\n  // We avoid using AbortController here, as it would mean creating\n  // a new instance for every SbbSlotStateController instance.\n  private _slotchangeHandler = (event: Event): void => {\n    this._syncSlots(event.target as HTMLSlotElement);\n  };\n\n  private _syncSlots(...slots: HTMLSlotElement[]): void {\n    for (const slot of slots) {\n      const slotName = slot.name || 'unnamed';\n      // We want to check, whether an element is slotted or a text node with actual content.\n      if (slot.assignedNodes().some((n) => 'tagName' in n || n.textContent?.trim())) {\n        this.slots.add(slotName);\n      } else {\n        this.slots.delete(slotName);\n      }\n    }\n\n    const oldValue = this._host.getAttribute('data-slot-names');\n    const joinedSlotNames = [...this.slots].sort().join(' ');\n    if (!joinedSlotNames) {\n      this._host.removeAttribute('data-slot-names');\n    } else if (this._host.getAttribute('data-slot-names') !== joinedSlotNames) {\n      this._host.setAttribute('data-slot-names', joinedSlotNames);\n    }\n\n    if (joinedSlotNames !== oldValue) {\n      this._onChangeCallback?.();\n    }\n  }\n}\n"],"names":["element","_a"],"mappings":"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"}

package/development/core/dom/breakpoint.d.ts

@@ -6,9 +6,10 @@ export type Breakpoint = (typeof breakpoints)[number];
  *
  * @param from The breakpoint corresponding to the `min-width` value of the media query (optional).
  * @param to The breakpoint corresponding to the `max-width` value of the media query (optional).
+ * @param properties Whether the max breakpoint should be included
  * @returns A boolean indicating whether the window matches the breakpoint.
  */
 export declare function isBreakpoint(from?: Breakpoint, to?: Breakpoint, properties?: {
     includeMaxBreakpoint: boolean;
-}): boolean;
+}): boolean | null;
 //# sourceMappingURL=breakpoint.d.ts.map

package/development/core/dom/breakpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"breakpoint.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/dom/breakpoint.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,yEAA0E,CAAC;AACnG,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,CAAC,EAAE,UAAU,EACjB,EAAE,CAAC,EAAE,UAAU,EACf,UAAU,CAAC,EAAE;IAAE,oBAAoB,EAAE,OAAO,CAAA;CAAE,GAC7C,OAAO,CAuBT"}
+{"version":3,"file":"breakpoint.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/dom/breakpoint.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,yEAA0E,CAAC;AACnG,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,IAAI,CAAC,EAAE,UAAU,EACjB,EAAE,CAAC,EAAE,UAAU,EACf,UAAU,CAAC,EAAE;IAAE,oBAAoB,EAAE,OAAO,CAAA;CAAE,GAC7C,OAAO,GAAG,IAAI,CAsBhB"}