@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771849268

package/development/core/controllers/inert-controller.js

@@ -0,0 +1,106 @@
+const IGNORED_ELEMENTS = ["script", "head", "template", "style"];
+const inertElements = /* @__PURE__ */ new Set();
+const exemptedElements = /* @__PURE__ */ new Set();
+const inertOverlays = /* @__PURE__ */ new Set();
+class SbbInertController {
+  constructor(_host, _inertElements = inertElements, _inertOverlays = inertOverlays, _exemptedElements = exemptedElements) {
+    this._host = _host;
+    this._inertElements = _inertElements;
+    this._inertOverlays = _inertOverlays;
+    this._exemptedElements = _exemptedElements;
+    this._host.addController?.(this);
+  }
+  hostConnected() {
+    if (this._host.isOpen) {
+      this.activate();
+    }
+  }
+  hostDisconnected() {
+    if (this.isInert()) {
+      this.deactivate();
+    }
+  }
+  /** Applies inert state to every other element on the page except the overlay. */
+  activate() {
+    if (this._inertOverlays.size) {
+      this._removeAllInertAttributes();
+    }
+    this._inertOverlays.add(this._host);
+    this._addAllInertAttributes();
+  }
+  /** Removes inert state. */
+  deactivate() {
+    if (this._currentOverlay() !== this._host) {
+      if (this._inertOverlays.has(this._host)) {
+        this._inertOverlays.delete(this._host);
+      }
+      return;
+    }
+    this._removeAllInertAttributes();
+    this._inertOverlays.delete(this._host);
+    if (this._inertOverlays.size) {
+      this._addAllInertAttributes();
+    }
+  }
+  /** Whether the assigned host is currently inert */
+  isInert() {
+    return this._inertOverlays.has(this._host);
+  }
+  /** Temporarily removes all inert attributes from a given element. */
+  exempt(element) {
+    if (this._inertElements.has(element) && !this._exemptedElements.has(element)) {
+      this._removeInertAttributes(element);
+      this._inertElements.delete(element);
+      this._exemptedElements.add(element);
+    }
+  }
+  /** Inerts an element currently exempted from inert. */
+  restoreAllExempted() {
+    this._exemptedElements.forEach((e) => this._addInertAttributes(e));
+    this._exemptedElements.clear();
+  }
+  _currentOverlay() {
+    return [...this._inertOverlays].pop() ?? null;
+  }
+  _removeAllInertAttributes() {
+    this._inertElements.forEach((element) => this._removeInertAttributes(element));
+    this._inertElements.clear();
+  }
+  _removeInertAttributes(element) {
+    if (!element) {
+      return;
+    }
+    if (element.hasAttribute("data-sbb-inert")) {
+      element.inert = false;
+      element.removeAttribute("data-sbb-inert");
+    }
+    if (element.hasAttribute("data-sbb-aria-hidden")) {
+      element.removeAttribute("aria-hidden");
+      element.removeAttribute("data-sbb-aria-hidden");
+    }
+  }
+  _addAllInertAttributes() {
+    let element = this._currentOverlay();
+    while (element !== document.documentElement && element !== null) {
+      Array.from((element?.parentElement ?? element?.getRootNode())?.childNodes ?? []).filter((child) => child !== element && child instanceof window.HTMLElement && !IGNORED_ELEMENTS.includes(child.localName) && !child.classList.contains("sbb-live-announcer-element")).forEach((element2) => {
+        this._addInertAttributes(element2);
+      });
+      element = element?.parentElement ?? element?.getRootNode()?.host ?? null;
+    }
+  }
+  _addInertAttributes(element) {
+    this._inertElements.add(element);
+    if (!element.inert) {
+      element.inert = true;
+      element.toggleAttribute("data-sbb-inert", true);
+    }
+    if (!element.hasAttribute("aria-hidden")) {
+      element.setAttribute("aria-hidden", "true");
+      element.toggleAttribute("data-sbb-aria-hidden", true);
+    }
+  }
+}
+export {
+  SbbInertController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"inert-controller.js","sources":["../../../../../src/elements/core/controllers/inert-controller.ts"],"sourcesContent":["import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nimport type { SbbOpenCloseBaseElement } from '../base-elements.ts';\n\nconst IGNORED_ELEMENTS = ['script', 'head', 'template', 'style'];\nconst inertElements = new Set<HTMLElement>();\nconst exemptedElements = 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    private _exemptedElements = exemptedElements,\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.isInert()) {\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._removeAllInertAttributes();\n    }\n\n    this._inertOverlays.add(this._host);\n    this._addAllInertAttributes();\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._removeAllInertAttributes();\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._addAllInertAttributes();\n    }\n  }\n\n  /** Whether the assigned host is currently inert */\n  public isInert(): boolean {\n    return this._inertOverlays.has(this._host);\n  }\n\n  /** Temporarily removes all inert attributes from a given element. */\n  public exempt(element: HTMLElement): void {\n    if (this._inertElements.has(element) && !this._exemptedElements.has(element)) {\n      this._removeInertAttributes(element);\n      this._inertElements.delete(element);\n      this._exemptedElements.add(element);\n    }\n  }\n\n  /** Inerts an element currently exempted from inert. */\n  public restoreAllExempted(): void {\n    this._exemptedElements.forEach((e) => this._addInertAttributes(e));\n    this._exemptedElements.clear();\n  }\n\n  private _currentOverlay(): HTMLElement | null {\n    return [...this._inertOverlays].pop() ?? null;\n  }\n\n  private _removeAllInertAttributes(): void {\n    this._inertElements.forEach((element: HTMLElement): void =>\n      this._removeInertAttributes(element),\n    );\n    this._inertElements.clear();\n  }\n\n  private _removeInertAttributes(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\n  private _addAllInertAttributes(): 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            !child.classList.contains('sbb-live-announcer-element'),\n        )\n        .forEach((element) => {\n          this._addInertAttributes(element);\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  private _addInertAttributes(element: HTMLElement): void {\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"],"names":["element"],"mappings":"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"}

package/development/core/controllers/language-controller.d.ts

@@ -0,0 +1,32 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * The LanguageController is a reactive controller that observes the "lang" attribute
+ * of the <html> tag.
+ * On change of the "lang" attribute, it will request an update of connected
+ * components.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang
+ */
+export declare class SbbLanguageController implements ReactiveController {
+    private _host;
+    private static readonly _defaultLanguage;
+    private static readonly _supportedLocales;
+    /** A set of connected components that should be notified on language change. */
+    private static readonly _listeners;
+    /** MutationObserver that observes the "lang" attribute of the <html> element. */
+    private static readonly _observer;
+    private static readonly _observerConfig;
+    /** Get the current language. */
+    static get current(): string;
+    /** Get the current language. */
+    get current(): string;
+    private _previousLanguage?;
+    private _handlers;
+    constructor(_host: ReactiveControllerHost);
+    /** Add a language change handler. */
+    withHandler(handler: () => void): this;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private _callHandlers;
+}
+//# sourceMappingURL=language-controller.d.ts.map

package/development/core/controllers/language-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/language-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAIrF;;;;;;;GAOG;AACH,qBAAa,qBAAsB,YAAW,kBAAkB;IA4C3C,OAAO,CAAC,KAAK;IA3ChC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IAChD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAA4B;IAErE,gFAAgF;IAChF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAoC;IAEtE,iFAAiF;IACjF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAMxB;IACT,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAGrC;IAEF,gCAAgC;IAChC,WAAkB,OAAO,IAAI,MAAM,CAalC;IAED,gCAAgC;IAChC,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,OAAO,CAAC,iBAAiB,CAAC,CAAS;IACnC,OAAO,CAAC,SAAS,CAAsB;gBAEZ,KAAK,EAAE,sBAAsB;IAIxD,qCAAqC;IAC9B,WAAW,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI;IAOtC,aAAa,IAAI,IAAI;IAiBrB,gBAAgB,IAAI,IAAI;IAW/B,OAAO,CAAC,aAAa;CAMtB"}

package/development/core/controllers/language-controller.js

@@ -0,0 +1,69 @@
+import { isServer } from "lit";
+import { readConfig } from "../config.js";
+const _SbbLanguageController = class _SbbLanguageController {
+  /** Get the current language. */
+  static get current() {
+    const language = (readConfig().language ?? (isServer ? _SbbLanguageController._defaultLanguage : document.documentElement.getAttribute("lang"))) || _SbbLanguageController._defaultLanguage;
+    const langAttributeNormalized = language.split("-")[0];
+    return _SbbLanguageController._supportedLocales.includes(langAttributeNormalized) ? langAttributeNormalized : _SbbLanguageController._defaultLanguage;
+  }
+  /** Get the current language. */
+  get current() {
+    return _SbbLanguageController.current;
+  }
+  constructor(_host) {
+    this._host = _host;
+    this._handlers = [];
+    this._host.addController(this);
+  }
+  /** Add a language change handler. */
+  withHandler(handler) {
+    this._handlers.unshift(handler);
+    return this;
+  }
+  hostConnected() {
+    if (isServer) {
+      return;
+    }
+    if (!_SbbLanguageController._listeners.size) {
+      _SbbLanguageController._observer.observe(document.documentElement, _SbbLanguageController._observerConfig);
+    }
+    _SbbLanguageController._listeners.add(this);
+    if (this._previousLanguage !== this.current) {
+      this._callHandlers(this._previousLanguage !== void 0);
+    }
+  }
+  hostDisconnected() {
+    if (isServer) {
+      return;
+    }
+    this._previousLanguage = this.current;
+    _SbbLanguageController._listeners.delete(this);
+    if (!_SbbLanguageController._listeners.size) {
+      _SbbLanguageController._observer.disconnect();
+    }
+  }
+  _callHandlers(requestUpdate = true) {
+    this._handlers.forEach((h) => h());
+    if (requestUpdate) {
+      this._host.requestUpdate();
+    }
+  }
+};
+_SbbLanguageController._defaultLanguage = "en";
+_SbbLanguageController._supportedLocales = ["en", "de", "fr", "it"];
+_SbbLanguageController._listeners = /* @__PURE__ */ new Set();
+_SbbLanguageController._observer = !isServer ? new MutationObserver((mutations) => {
+  if (mutations[0].oldValue !== document.documentElement.getAttribute("lang")) {
+    _SbbLanguageController._listeners.forEach((l) => l._callHandlers());
+  }
+}) : null;
+_SbbLanguageController._observerConfig = {
+  attributeFilter: ["lang"],
+  attributeOldValue: true
+};
+let SbbLanguageController = _SbbLanguageController;
+export {
+  SbbLanguageController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,65 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+import { SbbElementInternalsMixinType } from '../mixins.ts';
+export declare const SbbMediaQueryForcedColors = "(forced-colors: active)";
+export declare const SbbMediaQueryDarkMode = "(prefers-color-scheme: dark)";
+export declare const SbbMediaQueryHover = "(any-hover: hover)";
+export declare const SbbMediaQueryPointerCoarse = "(pointer: coarse)";
+export declare const SbbMediaQueryBreakpointZeroAndAbove: string;
+export declare const SbbMediaQueryBreakpointSmallAndAbove: string;
+export declare const SbbMediaQueryBreakpointLargeAndAbove: string;
+export declare const SbbMediaQueryBreakpointUltraAndAbove: string;
+export declare const SbbMediaQueryBreakpointSmallAndBelow: string;
+export declare const SbbMediaQueryBreakpointLargeAndBelow: 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;
+}
+/**
+ * A specialized version of the SbbMediaMatcherController, which
+ * takes the color-scheme CSS property into account when determining
+ * the dark mode state and updates a :state(dark) on the host.
+ *
+ * @example
+ * new SbbDarkModeController(this, (isDarkMode) => doSomething(isDarkMode));
+ */
+export declare class SbbDarkModeController extends SbbMediaMatcherController {
+    private _host;
+    /** The current mode based on the class attribute of the <html> element. */
+    private static _currentMode;
+    /** MutationObserver that observes the "class" attribute of the <html> element. */
+    private static readonly _observer;
+    private static readonly _observerConfig;
+    private readonly _onChangeWithStateUpdater;
+    constructor(_host: ReactiveControllerHost & HTMLElement & SbbElementInternalsMixinType, onChange: SbbMediaMatcherHandler);
+    private static _readLightDarkClass;
+    /**
+     * Requests an update of the dark mode state. This is needed when the color-scheme
+     * CSS property changes, as the media query does not pick this up automatically.
+     */
+    static requestUpdate(): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    matches(): boolean;
+}
+//# 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":"AAQA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAGrF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAC;AAGjE,eAAO,MAAM,yBAAyB,4BAA4B,CAAC;AACnE,eAAO,MAAM,qBAAqB,iCAAiC,CAAC;AACpE,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AACvD,eAAO,MAAM,0BAA0B,sBAAsB,CAAC;AAC9D,eAAO,MAAM,mCAAmC,QAAyC,CAAC;AAC1F,eAAO,MAAM,oCAAoC,QAA0C,CAAC;AAC5F,eAAO,MAAM,oCAAoC,QAA0C,CAAC;AAC5F,eAAO,MAAM,oCAAoC,QAA0C,CAAC;AAC5F,eAAO,MAAM,oCAAoC,QAA0C,CAAC;AAC5F,eAAO,MAAM,oCAAoC,QAA0C,CAAC;AAG5F;;;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;IAMtC,aAAa,IAAI,IAAI;IAoBrB,gBAAgB,IAAI,IAAI;CAWhC;AAED;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,yBAAyB;IA0BhE,OAAO,CAAC,KAAK;IAzBf,2EAA2E;IAC3E,OAAO,CAAC,MAAM,CAAC,YAAY,CACE;IAE7B,kFAAkF;IAClF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAUxB;IAET,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAGrC;IAEF,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAa;gBAG7C,KAAK,EAAE,sBAAsB,GAAG,WAAW,GAAG,4BAA4B,EAClF,QAAQ,EAAE,sBAAsB;IAYlC,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAYlC;;;OAGG;WAEW,aAAa,IAAI,IAAI;IAOnB,aAAa,IAAI,IAAI;IAerB,gBAAgB,IAAI,IAAI;IAQxB,OAAO,IAAI,OAAO;CAWnC"}

package/development/core/controllers/media-matchers-controller.js

@@ -0,0 +1,141 @@
+import { S as SbbBreakpointLargeMin, a as SbbBreakpointLargeMax, b as SbbBreakpointSmallMin, c as SbbBreakpointSmallMax, d as SbbBreakpointUltraMin, e as SbbBreakpointZeroMin } from "../../sbb-tokens-DQT_xEIZ.js";
+import { isServer } from "lit";
+import { ɵstateController as _stateController } from "../mixins/element-internals-mixin.js";
+const SbbMediaQueryForcedColors = "(forced-colors: active)";
+const SbbMediaQueryDarkMode = "(prefers-color-scheme: dark)";
+const SbbMediaQueryHover = "(any-hover: hover)";
+const SbbMediaQueryPointerCoarse = "(pointer: coarse)";
+const SbbMediaQueryBreakpointZeroAndAbove = `(min-width: ${SbbBreakpointZeroMin})`;
+const SbbMediaQueryBreakpointSmallAndAbove = `(min-width: ${SbbBreakpointSmallMin})`;
+const SbbMediaQueryBreakpointLargeAndAbove = `(min-width: ${SbbBreakpointLargeMin})`;
+const SbbMediaQueryBreakpointUltraAndAbove = `(min-width: ${SbbBreakpointUltraMin})`;
+const SbbMediaQueryBreakpointSmallAndBelow = `(max-width: ${SbbBreakpointSmallMax})`;
+const SbbMediaQueryBreakpointLargeAndBelow = `(max-width: ${SbbBreakpointLargeMax})`;
+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) {
+    return isServer ? null : 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);
+        }
+      }
+    }
+  }
+}
+const _SbbDarkModeController = class _SbbDarkModeController extends SbbMediaMatcherController {
+  constructor(_host, onChange) {
+    const onChangeWithStateUpdater = () => {
+      onChange(this.matches());
+      _stateController(this._host).toggle("dark", this.matches());
+    };
+    super(_host, {
+      [SbbMediaQueryDarkMode]: onChangeWithStateUpdater
+    });
+    this._host = _host;
+    this._onChangeWithStateUpdater = onChangeWithStateUpdater;
+  }
+  static _readLightDarkClass() {
+    if (isServer) {
+      return null;
+    }
+    const classList = document.documentElement.classList;
+    return ["sbb-light-dark", "sbb-dark", "sbb-light"].find((mode) => classList.contains(mode)) ?? null;
+  }
+  /**
+   * Requests an update of the dark mode state. This is needed when the color-scheme
+   * CSS property changes, as the media query does not pick this up automatically.
+   */
+  // eslint-disable-next-line lyne/needs-super-call-rule
+  static requestUpdate() {
+    const entry = mediaQueryRegistry.get(SbbMediaQueryDarkMode);
+    if (entry) {
+      entry.handlers.forEach((h) => h(entry.mediaQueryList.matches));
+    }
+  }
+  hostConnected() {
+    const isFirstListener = (mediaQueryRegistry.get(SbbMediaQueryDarkMode)?.handlers.size ?? 0) === 0;
+    super.hostConnected();
+    if (isFirstListener) {
+      _SbbDarkModeController._observer.observe(document.documentElement, _SbbDarkModeController._observerConfig);
+    }
+    this._onChangeWithStateUpdater();
+  }
+  hostDisconnected() {
+    super.hostDisconnected();
+    if ((mediaQueryRegistry.get(SbbMediaQueryDarkMode)?.handlers.size ?? 0) === 0) {
+      _SbbDarkModeController._observer.disconnect();
+    }
+  }
+  matches() {
+    if (isServer) {
+      return false;
+    }
+    const colorScheme = getComputedStyle(this._host).getPropertyValue("color-scheme");
+    const darkAvailable = colorScheme.includes("dark");
+    const darkOnly = colorScheme.trim() === "dark";
+    const preferredDarkMode = super.matches(SbbMediaQueryDarkMode);
+    return preferredDarkMode && darkAvailable || darkOnly;
+  }
+};
+_SbbDarkModeController._currentMode = _SbbDarkModeController._readLightDarkClass();
+_SbbDarkModeController._observer = !isServer ? new MutationObserver((mutations) => {
+  if (mutations[0].oldValue !== document.documentElement.getAttribute("class")) {
+    const newMode = _SbbDarkModeController._readLightDarkClass();
+    if (_SbbDarkModeController._currentMode !== newMode) {
+      _SbbDarkModeController.requestUpdate();
+      _SbbDarkModeController._currentMode = newMode;
+    }
+  }
+}) : null;
+_SbbDarkModeController._observerConfig = {
+  attributeFilter: ["class"],
+  attributeOldValue: true
+};
+let SbbDarkModeController = _SbbDarkModeController;
+export {
+  SbbDarkModeController,
+  SbbMediaMatcherController,
+  SbbMediaQueryBreakpointLargeAndAbove,
+  SbbMediaQueryBreakpointLargeAndBelow,
+  SbbMediaQueryBreakpointSmallAndAbove,
+  SbbMediaQueryBreakpointSmallAndBelow,
+  SbbMediaQueryBreakpointUltraAndAbove,
+  SbbMediaQueryBreakpointZeroAndAbove,
+  SbbMediaQueryDarkMode,
+  SbbMediaQueryForcedColors,
+  SbbMediaQueryHover,
+  SbbMediaQueryPointerCoarse
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"media-matchers-controller.js","sources":["../../../../../src/elements/core/controllers/media-matchers-controller.ts"],"sourcesContent":["import {\n  SbbBreakpointLargeMax,\n  SbbBreakpointLargeMin,\n  SbbBreakpointSmallMax,\n  SbbBreakpointSmallMin,\n  SbbBreakpointUltraMin,\n  SbbBreakpointZeroMin,\n} from '@sbb-esta/lyne-design-tokens';\nimport { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nimport { ɵstateController } from '../mixins/element-internals-mixin.ts';\nimport type { SbbElementInternalsMixinType } from '../mixins.ts';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport const SbbMediaQueryForcedColors = '(forced-colors: active)';\nexport const SbbMediaQueryDarkMode = '(prefers-color-scheme: dark)';\nexport const SbbMediaQueryHover = '(any-hover: hover)';\nexport const SbbMediaQueryPointerCoarse = '(pointer: coarse)';\nexport const SbbMediaQueryBreakpointZeroAndAbove = `(min-width: ${SbbBreakpointZeroMin})`;\nexport const SbbMediaQueryBreakpointSmallAndAbove = `(min-width: ${SbbBreakpointSmallMin})`;\nexport const SbbMediaQueryBreakpointLargeAndAbove = `(min-width: ${SbbBreakpointLargeMin})`;\nexport const SbbMediaQueryBreakpointUltraAndAbove = `(min-width: ${SbbBreakpointUltraMin})`;\nexport const SbbMediaQueryBreakpointSmallAndBelow = `(max-width: ${SbbBreakpointSmallMax})`;\nexport const SbbMediaQueryBreakpointLargeAndBelow = `(max-width: ${SbbBreakpointLargeMax})`;\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 we use the cached instance, Webkit seems to update the state a tick too late.\n    // Due to this we directly use matchMedia here.\n    return isServer ? null : matchMedia(query).matches;\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\n/**\n * A specialized version of the SbbMediaMatcherController, which\n * takes the color-scheme CSS property into account when determining\n * the dark mode state and updates a :state(dark) on the host.\n *\n * @example\n * new SbbDarkModeController(this, (isDarkMode) => doSomething(isDarkMode));\n */\nexport class SbbDarkModeController extends SbbMediaMatcherController {\n  /** The current mode based on the class attribute of the <html> element. */\n  private static _currentMode: 'sbb-light-dark' | 'sbb-light' | 'sbb-dark' | null =\n    this._readLightDarkClass();\n\n  /** MutationObserver that observes the \"class\" attribute of the <html> element. */\n  private static readonly _observer = !isServer\n    ? new MutationObserver((mutations) => {\n        if (mutations[0].oldValue !== document.documentElement.getAttribute('class')) {\n          const newMode = this._readLightDarkClass();\n          if (this._currentMode !== newMode) {\n            SbbDarkModeController.requestUpdate();\n            this._currentMode = newMode;\n          }\n        }\n      })\n    : null;\n\n  private static readonly _observerConfig = {\n    attributeFilter: ['class'],\n    attributeOldValue: true,\n  };\n\n  private readonly _onChangeWithStateUpdater: () => void;\n\n  public constructor(\n    private _host: ReactiveControllerHost & HTMLElement & SbbElementInternalsMixinType,\n    onChange: SbbMediaMatcherHandler,\n  ) {\n    const onChangeWithStateUpdater: () => void = () => {\n      onChange(this.matches());\n      ɵstateController(this._host).toggle('dark', this.matches());\n    };\n    super(_host, {\n      [SbbMediaQueryDarkMode]: onChangeWithStateUpdater,\n    });\n    this._onChangeWithStateUpdater = onChangeWithStateUpdater;\n  }\n\n  private static _readLightDarkClass(): 'sbb-light-dark' | 'sbb-light' | 'sbb-dark' | null {\n    if (isServer) {\n      return null;\n    }\n    const classList = document.documentElement.classList;\n    return (\n      (['sbb-light-dark', 'sbb-dark', 'sbb-light'] as const).find((mode) =>\n        classList.contains(mode),\n      ) ?? null\n    );\n  }\n\n  /**\n   * Requests an update of the dark mode state. This is needed when the color-scheme\n   * CSS property changes, as the media query does not pick this up automatically.\n   */\n  // eslint-disable-next-line lyne/needs-super-call-rule\n  public static requestUpdate(): void {\n    const entry = mediaQueryRegistry.get(SbbMediaQueryDarkMode);\n    if (entry) {\n      entry.handlers.forEach((h) => h(entry.mediaQueryList.matches));\n    }\n  }\n\n  public override hostConnected(): void {\n    const isFirstListener =\n      (mediaQueryRegistry.get(SbbMediaQueryDarkMode)?.handlers.size ?? 0) === 0;\n    super.hostConnected();\n\n    if (isFirstListener) {\n      SbbDarkModeController._observer!.observe(\n        document.documentElement,\n        SbbDarkModeController._observerConfig,\n      );\n    }\n\n    this._onChangeWithStateUpdater();\n  }\n\n  public override hostDisconnected(): void {\n    super.hostDisconnected();\n\n    if ((mediaQueryRegistry.get(SbbMediaQueryDarkMode)?.handlers.size ?? 0) === 0) {\n      SbbDarkModeController._observer!.disconnect();\n    }\n  }\n\n  public override matches(): boolean {\n    if (isServer) {\n      return false;\n    }\n    const colorScheme = getComputedStyle(this._host).getPropertyValue('color-scheme');\n    const darkAvailable = colorScheme.includes('dark');\n    const darkOnly = colorScheme.trim() === 'dark';\n    const preferredDarkMode = super.matches(SbbMediaQueryDarkMode) as boolean;\n\n    return (preferredDarkMode && darkAvailable) || darkOnly;\n  }\n}\n"],"names":["ɵstateController"],"mappings":"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"}

package/development/core/controllers/overlay-position-controller.d.ts

@@ -0,0 +1,61 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+import { SbbElementInternalsMixinType } from '../mixins.ts';
+/**
+ * Controller for managing overlays positioning. Also acts as a polyfill when native
+ * CSS Anchor Positioning is not supported (enough).
+ * Applies unique anchor names when using native CSS Anchor Positioning
+ * or calculates and applies correct positions in polyfill mode.
+ *
+ * Also, the controller sets the 'data-position' attribute on the overlay element.
+ * This can be used to apply specific styles based on the current position of the overlay.
+ *
+ * ### Implementation
+ * Define and apply the following CSS variables on the overlay element:
+ * ```scss
+ *   --sbb-overlay-position-area: block-end; // Default
+ *   --sbb-overlay-position-try-fallbacks: block-start, inline-end, inline-start; // Fallbacks
+ *
+ *   position-area: var(--sbb-overlay-position-area);
+ *   position-try-fallbacks: var(--sbb-overlay-position-try-fallbacks);
+ * ```
+ */
+export declare class SbbOverlayPositionController implements ReactiveController {
+    private _usePolyfill;
+    private readonly _resizeObserver;
+    private readonly _overlay;
+    private _abortController?;
+    private _anchor?;
+    private _overlayStyles?;
+    private _frame?;
+    private _anchorName;
+    private _positions;
+    private _lastPosition?;
+    /** Get the current position. (e.g. block-end, block-start, etc.) */
+    get currentPosition(): string;
+    constructor(host: ReactiveControllerHost & HTMLElement & SbbElementInternalsMixinType, _usePolyfill?: boolean);
+    hostConnected(): void;
+    hostUpdate(): void;
+    /**
+     * Connects the overlay to the given trigger element and determines the optimal position.
+     * Usually, this is called when the overlay is opened.
+     * @param anchor The anchor element.
+     */
+    connect(anchor: HTMLElement): void;
+    disconnect(): void;
+    private _requestCalculatePosition;
+    private _calculatePosition;
+    /**
+     * Calculates the optimal position that fits the overlay.
+     * @param positions The list of positions to check.
+     * @private
+     */
+    private _getOptimalPosition;
+    private _applyOverlayPosition;
+    /**
+     * Only used in polyfill mode.
+     * Reads the list of the configured positions from the CSS variables.
+     * @private
+     */
+    private _readPositionsFromCss;
+}
+//# sourceMappingURL=overlay-position-controller.d.ts.map

package/development/core/controllers/overlay-position-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-position-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/overlay-position-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAErF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAC;AAqDjE;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,4BAA6B,YAAW,kBAAkB;IAyBnE,OAAO,CAAC,YAAY;IAxBtB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAEtB;IACV,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsE;IAC/F,OAAO,CAAC,gBAAgB,CAAC,CAAkB;IAC3C,OAAO,CAAC,OAAO,CAAC,CAAc;IAC9B,OAAO,CAAC,cAAc,CAAC,CAAsB;IAC7C,OAAO,CAAC,MAAM,CAAC,CAA2C;IAC1D,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,aAAa,CAAC,CAAS;IAE/B,oEAAoE;IACpE,IAAW,eAAe,IAAI,MAAM,CAOnC;gBAGC,IAAI,EAAE,sBAAsB,GAAG,WAAW,GAAG,4BAA4B,EACjE,YAAY,UAA8B;IAM7C,aAAa,IAAI,IAAI;IASrB,UAAU,IAAI,IAAI;IAOzB;;;;OAIG;IACI,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAmClC,UAAU,IAAI,IAAI;IAOzB,OAAO,CAAC,yBAAyB;IAOjC,OAAO,CAAC,kBAAkB;IAa1B;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAkL3B,OAAO,CAAC,qBAAqB;IAM7B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;CA6B9B"}