@sbb-esta/lyne-elements 4.7.0 → 4.8.0

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

@@ -1,141 +1,148 @@
-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 { c as SbbBreakpointZeroMin, i as SbbBreakpointSmallMin, n as SbbBreakpointLargeMin, o as SbbBreakpointUltraMin, r as SbbBreakpointSmallMax, t as SbbBreakpointLargeMax } from "../../sbb-tokens-Lrm4nvNH.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;
-  }
+import { ɵstateController } from "../mixins/element-internals-mixin.js";
+//#region src/elements/core/controllers/media-matchers-controller.ts
+var SbbMediaQueryForcedColors = "(forced-colors: active)";
+var SbbMediaQueryDarkMode = "(prefers-color-scheme: dark)";
+var SbbMediaQueryHover = "(any-hover: hover)";
+var SbbMediaQueryPointerCoarse = "(pointer: coarse)";
+var SbbMediaQueryBreakpointZeroAndAbove = `(min-width: ${SbbBreakpointZeroMin})`;
+var SbbMediaQueryBreakpointSmallAndAbove = `(min-width: ${SbbBreakpointSmallMin})`;
+var SbbMediaQueryBreakpointLargeAndAbove = `(min-width: ${SbbBreakpointLargeMin})`;
+var SbbMediaQueryBreakpointUltraAndAbove = `(min-width: ${SbbBreakpointUltraMin})`;
+var SbbMediaQueryBreakpointSmallAndBelow = `(max-width: ${SbbBreakpointSmallMax})`;
+var SbbMediaQueryBreakpointLargeAndBelow = `(max-width: ${SbbBreakpointLargeMax})`;
+/**
+* We want to cache MediaQueryList instances and corresponding
+* event handlers, as a multitude of event handlers on global objects
+* can degrade performance with time.
+*/
+var mediaQueryRegistry = /* @__PURE__ */ new Map();
+/**
+* This controller allows listening to media query changes.
+*
+* @example
+* new SbbMediaMatcherController(this, {
+*   [SbbForcedColorsQuery]: (matches) => doSomething(matches),
+* })
+*/
+var SbbMediaMatcherController = class {
+	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 = 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);
+			}
+		}
+	}
 };
-_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
+/**
+* A specialized version of the SbbMediaMatcherController, which
+* takes the color-scheme CSS property into account when determining
+* the dark mode state and updates a :is(:state(dark),[state--dark]) on the host.
+*
+* @example
+* new SbbDarkModeController(this, (isDarkMode) => doSomething(isDarkMode));
+*/
+var SbbDarkModeController = class SbbDarkModeController extends SbbMediaMatcherController {
+	/** The current mode based on the class attribute of the <html> element. */
+	static {
+		this._currentMode = this._readLightDarkClass();
+	}
+	/** MutationObserver that observes the "class" attribute of the <html> element. */
+	static {
+		this._observer = !isServer ? new MutationObserver((mutations) => {
+			if (mutations[0].oldValue !== document.documentElement.getAttribute("class")) {
+				const newMode = this._readLightDarkClass();
+				if (this._currentMode !== newMode) {
+					SbbDarkModeController.requestUpdate();
+					this._currentMode = newMode;
+				}
+			}
+		}) : null;
+	}
+	static {
+		this._observerConfig = {
+			attributeFilter: ["class"],
+			attributeOldValue: true
+		};
+	}
+	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.
+	*/
+	static requestUpdate() {
+		const entry = mediaQueryRegistry.get(SbbMediaQueryDarkMode);
+		if (entry) entry.handlers.forEach((h) => h(entry.mediaQueryList.matches));
+	}
+	hostConnected() {
+		const isFirstListener = (mediaQueryRegistry.get("(prefers-color-scheme: dark)")?.handlers.size ?? 0) === 0;
+		super.hostConnected();
+		if (isFirstListener) SbbDarkModeController._observer.observe(document.documentElement, SbbDarkModeController._observerConfig);
+		this._onChangeWithStateUpdater();
+	}
+	hostDisconnected() {
+		super.hostDisconnected();
+		if ((mediaQueryRegistry.get("(prefers-color-scheme: dark)")?.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";
+		return super.matches("(prefers-color-scheme: dark)") && darkAvailable || darkOnly;
+	}
 };
-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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"}
+//#endregion
+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","names":[],"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"],"mappings":"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"}