@sbb-esta/lyne-elements-dev 4.7.0-dev.1773388991 → 4.7.0-dev.1773396165

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

@@ -1,148 +1,141 @@
-import { c as SbbBreakpointZeroMin, i as SbbBreakpointSmallMin, n as SbbBreakpointLargeMin, o as SbbBreakpointUltraMin, r as SbbBreakpointSmallMax, t as SbbBreakpointLargeMax } from "../../sbb-tokens-Dajio3u-.js";
+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 } 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);
-			}
-		}
-	}
+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;
+  }
 };
-/**
-* 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;
-	}
+_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
 };
-//#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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"}
+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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"}