@sbb-esta/lyne-elements 2.6.0 → 2.7.0

package/development/core/controllers/id-observer-controller.js

@@ -0,0 +1,84 @@
+import { isServer } from "lit";
+const observers = /* @__PURE__ */ new WeakMap();
+class SbbIdReferenceController {
+  constructor(_host, _idRef, _observers = observers) {
+    this._host = _host;
+    this._idRef = _idRef;
+    this._observers = _observers;
+    this._rootNode = null;
+    this._host.addController(this);
+  }
+  hostConnected() {
+    if (isServer) {
+      return;
+    }
+    this._rootNode = this._host.getRootNode();
+    const observerContext = this._observers.get(this._rootNode);
+    if (observerContext) {
+      observerContext.controllers.add(this);
+    } else {
+      const controllers = /* @__PURE__ */ new Set([this]);
+      const observer = new MutationObserver((mutations) => {
+        const mutatedIds = /* @__PURE__ */ new Set();
+        for (const mutation of mutations) {
+          if (mutation.type === "attributes") {
+            mutatedIds.add(mutation.oldValue);
+            mutatedIds.add(mutation.target.id);
+          } else if (mutation.type === "childList") {
+            for (const node of [...mutation.addedNodes, ...mutation.removedNodes]) {
+              if (node instanceof HTMLElement) {
+                mutatedIds.add(node.id);
+                node.querySelectorAll("[id]").forEach((e) => mutatedIds.add(e.id));
+              }
+            }
+          }
+        }
+        for (const controller of controllers) {
+          const id = controller._host[controller._idRef];
+          if (id && typeof id === "string" && mutatedIds.has(id)) {
+            controller._host.requestUpdate();
+          }
+        }
+      });
+      observer.observe(this._rootNode, {
+        attributeFilter: ["id"],
+        childList: true,
+        subtree: true,
+        attributeOldValue: true
+      });
+      this._observers.set(this._rootNode, { observer, controllers });
+    }
+  }
+  hostDisconnected() {
+    if (isServer || !this._rootNode) {
+      return;
+    }
+    const observerContext = this._observers.get(this._rootNode);
+    if (!observerContext) {
+      this._rootNode = null;
+      return;
+    }
+    observerContext.controllers.delete(this);
+    if (observerContext.controllers.size === 0) {
+      observerContext.observer.disconnect();
+      this._observers.delete(this._rootNode);
+    }
+    this._rootNode = null;
+  }
+  /**
+   * Find the element by id in the current document fragment
+   */
+  find() {
+    var _a;
+    if (isServer || !this._rootNode) {
+      return null;
+    } else {
+      const id = this._host[this._idRef];
+      return typeof id == "string" ? (_a = this._rootNode) == null ? void 0 : _a.querySelector(`#${id}`) : null;
+    }
+  }
+}
+export {
+  SbbIdReferenceController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,9 +1,11 @@
 import { ReactiveController, ReactiveControllerHost } from 'lit';
+import { SbbOpenCloseBaseElement } from '../base-elements.js';
 export declare class SbbInertController implements ReactiveController {
     private _host;
     private _inertElements;
     private _inertOverlays;
-    constructor(_host: ReactiveControllerHost & HTMLElement, _inertElements?: Set<HTMLElement>, _inertOverlays?: Set<HTMLElement>);
+    constructor(_host: ReactiveControllerHost & SbbOpenCloseBaseElement, _inertElements?: Set<HTMLElement>, _inertOverlays?: Set<HTMLElement>);
+    hostConnected(): void;
     hostDisconnected(): void;
     /** Applies inert state to every other element on the page except the overlay. */
     activate(): void;

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

@@ -1 +1 @@
-{"version":3,"file":"inert-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/inert-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAMtE,qBAAa,kBAAmB,YAAW,kBAAkB;IAEzD,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,cAAc;gBAFd,KAAK,EAAE,sBAAsB,GAAG,WAAW,EAC3C,cAAc,mBAAgB,EAC9B,cAAc,mBAAgB;IAKjC,gBAAgB,IAAI,IAAI;IAM/B,iFAAiF;IAC1E,QAAQ,IAAI,IAAI;IAUvB,2BAA2B;IACpB,UAAU,IAAI,IAAI;IAyBzB,mDAAmD;IAC5C,OAAO,IAAI,OAAO;IAIzB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,mBAAmB;CA6B5B"}
+{"version":3,"file":"inert-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/inert-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAEtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAMnE,qBAAa,kBAAmB,YAAW,kBAAkB;IAEzD,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,cAAc;gBAFd,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,EACvD,cAAc,mBAAgB,EAC9B,cAAc,mBAAgB;IAKjC,aAAa,IAAI,IAAI;IAMrB,gBAAgB,IAAI,IAAI;IAM/B,iFAAiF;IAC1E,QAAQ,IAAI,IAAI;IAUvB,2BAA2B;IACpB,UAAU,IAAI,IAAI;IAyBzB,mDAAmD;IAC5C,OAAO,IAAI,OAAO;IAIzB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,mBAAmB;CA6B5B"}

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

@@ -0,0 +1,91 @@
+const IGNORED_ELEMENTS = ["script", "head", "template", "style"];
+const inertElements = /* @__PURE__ */ new Set();
+const inertOverlays = /* @__PURE__ */ new Set();
+class SbbInertController {
+  constructor(_host, _inertElements = inertElements, _inertOverlays = inertOverlays) {
+    var _a, _b;
+    this._host = _host;
+    this._inertElements = _inertElements;
+    this._inertOverlays = _inertOverlays;
+    (_b = (_a = this._host).addController) == null ? void 0 : _b.call(_a, 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._removeInertAttributes();
+    }
+    this._inertOverlays.add(this._host);
+    this._addInertAttributes();
+  }
+  /** Removes inert state. */
+  deactivate() {
+    if (this._currentOverlay() !== this._host) {
+      if (this._inertOverlays.has(this._host)) {
+        this._inertOverlays.delete(this._host);
+      } else {
+        console.warn("Trying to remove inert state of an overlay which never had an applied inert state.", this._host);
+      }
+      return;
+    }
+    this._removeInertAttributes();
+    this._inertOverlays.delete(this._host);
+    if (this._inertOverlays.size) {
+      this._addInertAttributes();
+    }
+  }
+  /** Whether the assigned host is currently inert */
+  isInert() {
+    return this._inertOverlays.has(this._host);
+  }
+  _currentOverlay() {
+    return [...this._inertOverlays].pop() ?? null;
+  }
+  _removeInertAttributes() {
+    this._inertElements.forEach((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");
+      }
+    });
+    this._inertElements.clear();
+  }
+  _addInertAttributes() {
+    var _a, _b;
+    let element = this._currentOverlay();
+    while (element !== document.documentElement && element !== null) {
+      Array.from(((_a = (element == null ? void 0 : element.parentElement) ?? (element == null ? void 0 : element.getRootNode())) == null ? void 0 : _a.childNodes) ?? []).filter((child) => child !== element && child instanceof window.HTMLElement && !IGNORED_ELEMENTS.includes(child.localName)).forEach((element2) => {
+        this._inertElements.add(element2);
+        if (!element2.inert) {
+          element2.inert = true;
+          element2.toggleAttribute("data-sbb-inert", true);
+        }
+        if (!element2.hasAttribute("aria-hidden")) {
+          element2.setAttribute("aria-hidden", "true");
+          element2.toggleAttribute("data-sbb-aria-hidden", true);
+        }
+      });
+      element = (element == null ? void 0 : element.parentElement) ?? ((_b = element == null ? void 0 : element.getRootNode()) == null ? void 0 : _b.host) ?? null;
+    }
+  }
+}
+export {
+  SbbInertController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -3,6 +3,7 @@ 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 SbbMediaQueryBreakpointMediumAndBelow: string;
 export declare const SbbMediaQueryBreakpointSmallAndBelow: string;
 /**
  * A callback, which is invoked when the associated media query match

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

@@ -1 +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;IAMtC,aAAa,IAAI,IAAI;IAoBrB,gBAAgB,IAAI,IAAI;CAWhC"}
+{"version":3,"file":"media-matchers-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/media-matchers-controller.ts"],"names":[],"mappings":"AAMA,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,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;IAMtC,aAAa,IAAI,IAAI;IAoBrB,gBAAgB,IAAI,IAAI;CAWhC"}

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

@@ -0,0 +1,62 @@
+import { S as SbbTypoScaleDefault, a as SbbBreakpointMediumMax, b as SbbBreakpointSmallMax, c as SbbBreakpointMediumMin } from "../../sbb-tokens-CVLcOi-S.js";
+import { isServer } from "lit";
+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 SbbMediaQueryBreakpointMediumAndBelow = `(max-width: ${pxToRem(SbbBreakpointMediumMax)}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) {
+    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);
+        }
+      }
+    }
+  }
+}
+export {
+  SbbMediaMatcherController,
+  SbbMediaQueryBreakpointMediumAndAbove,
+  SbbMediaQueryBreakpointMediumAndBelow,
+  SbbMediaQueryBreakpointSmallAndBelow,
+  SbbMediaQueryForcedColors,
+  SbbMediaQueryHover,
+  SbbMediaQueryPointerCoarse
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/controllers/slot-state-controller.js

@@ -0,0 +1,48 @@
+class SbbSlotStateController {
+  constructor(_host, _onChangeCallback = null) {
+    this._host = _host;
+    this._onChangeCallback = _onChangeCallback;
+    this.slots = /* @__PURE__ */ new Set();
+    this._slotchangeHandler = (event) => {
+      this._syncSlots(event.target);
+    };
+    this._host.addController(this);
+  }
+  hostConnected() {
+    var _a;
+    this._syncSlots(...this._host.querySelectorAll("slot"));
+    (_a = this._host.shadowRoot) == null ? void 0 : _a.addEventListener("slotchange", this._slotchangeHandler);
+  }
+  hostDisconnected() {
+    var _a;
+    (_a = this._host.shadowRoot) == null ? void 0 : _a.removeEventListener("slotchange", this._slotchangeHandler);
+  }
+  _syncSlots(...slots) {
+    var _a;
+    for (const slot of slots) {
+      const slotName = slot.name || "unnamed";
+      if (slot.assignedNodes().some((n) => {
+        var _a2;
+        return "tagName" in n || ((_a2 = n.textContent) == null ? void 0 : _a2.trim());
+      })) {
+        this.slots.add(slotName);
+      } else {
+        this.slots.delete(slotName);
+      }
+    }
+    const oldValue = this._host.getAttribute("data-slot-names");
+    const joinedSlotNames = [...this.slots].sort().join(" ");
+    if (!joinedSlotNames) {
+      this._host.removeAttribute("data-slot-names");
+    } else if (this._host.getAttribute("data-slot-names") !== joinedSlotNames) {
+      this._host.setAttribute("data-slot-names", joinedSlotNames);
+    }
+    if (joinedSlotNames !== oldValue) {
+      (_a = this._onChangeCallback) == null ? void 0 : _a.call(this);
+    }
+  }
+}
+export {
+  SbbSlotStateController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/controllers.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @entrypoint
+ */
 export * from './controllers/connected-abort-controller.js';
 export * from './controllers/escapable-overlay-controller.js';
 export * from './controllers/id-observer-controller.js';

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,+CAA+C,CAAC;AAC9D,cAAc,yCAAyC,CAAC;AACxD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC"}
+{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/controllers.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,6CAA6C,CAAC;AAC5D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,yCAAyC,CAAC;AACxD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC"}