@sbb-esta/lyne-elements-dev 4.7.0-dev.1773648103 → 4.7.0-dev.1773648656

package/development/core/a11y/live-announcer.js

@@ -1,82 +1,78 @@
 import { isServer } from "lit";
-let uniqueIds = 0;
-class SbbLiveAnnouncer {
-  constructor() {
-    if (!isServer) {
-      if (document.body) {
-        this._liveElement = this._createLiveElement();
-      } else {
-        document.addEventListener("DOMContentLoaded", () => {
-          this._liveElement = this._createLiveElement();
-        });
-      }
-    }
-  }
-  announce(message, ...args) {
-    if (!this._liveElement) {
-      return Promise.resolve();
-    }
-    const defaultOptions = {};
-    let politeness;
-    let duration;
-    if (args.length === 1 && typeof args[0] === "number") {
-      duration = args[0];
-    } else {
-      [politeness, duration] = args;
-    }
-    this.clear();
-    clearTimeout(this._previousTimeout);
-    politeness ??= defaultOptions?.politeness ?? "polite";
-    duration ??= defaultOptions?.duration;
-    this._liveElement.setAttribute("aria-live", politeness);
-    this._currentPromise ??= new Promise((resolve) => this._currentResolve = resolve);
-    clearTimeout(this._previousTimeout);
-    this._previousTimeout = setTimeout(() => {
-      this._liveElement.textContent = message;
-      if (typeof duration === "number") {
-        this._previousTimeout = setTimeout(() => this.clear(), duration);
-      }
-      this._currentResolve?.();
-      this._currentPromise = this._currentResolve = void 0;
-    }, 100);
-    return this._currentPromise;
-  }
-  /**
-   * Clears the current text from the announcer element. Can be used to prevent
-   * screen readers from reading the text out again while the user is going
-   * through the page landmarks.
-   */
-  clear() {
-    if (this._liveElement) {
-      this._liveElement.textContent = "";
-    }
-  }
-  destroy() {
-    clearTimeout(this._previousTimeout);
-    this._liveElement?.remove();
-    this._liveElement = null;
-    this._currentResolve?.();
-    this._currentPromise = this._currentResolve = void 0;
-  }
-  _createLiveElement() {
-    const elementClass = "sbb-live-announcer-element";
-    const previousElements = document.getElementsByClassName(elementClass);
-    const liveEl = document.createElement("div");
-    for (let i = 0; i < previousElements.length; i++) {
-      previousElements[i].remove();
-    }
-    liveEl.classList.add(elementClass);
-    liveEl.classList.add("sbb-screen-reader-only");
-    liveEl.setAttribute("aria-atomic", "true");
-    liveEl.setAttribute("aria-live", "polite");
-    liveEl.id = `sbb-live-announcer-${uniqueIds++}`;
-    document.body.appendChild(liveEl);
-    return liveEl;
-  }
-}
-const sbbLiveAnnouncer = new SbbLiveAnnouncer();
-export {
-  SbbLiveAnnouncer,
-  sbbLiveAnnouncer
+//#region src/elements/core/a11y/live-announcer.ts
+/**
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.dev/license
+*/
+var uniqueIds = 0;
+/**
+* Allows to announce messages to screen readers.
+*
+* Adapted from https://github.com/angular/components/blob/main/src/cdk/a11y/live-announcer/live-announcer.ts
+*/
+var SbbLiveAnnouncer = class {
+	constructor() {
+		if (!isServer) if (document.body) this._liveElement = this._createLiveElement();
+		else document.addEventListener("DOMContentLoaded", () => {
+			this._liveElement = this._createLiveElement();
+		});
+	}
+	announce(message, ...args) {
+		if (!this._liveElement) return Promise.resolve();
+		const defaultOptions = {};
+		let politeness;
+		let duration;
+		if (args.length === 1 && typeof args[0] === "number") duration = args[0];
+		else [politeness, duration] = args;
+		this.clear();
+		clearTimeout(this._previousTimeout);
+		politeness ??= defaultOptions?.politeness ?? "polite";
+		duration ??= defaultOptions?.duration;
+		this._liveElement.setAttribute("aria-live", politeness);
+		this._currentPromise ??= new Promise((resolve) => this._currentResolve = resolve);
+		clearTimeout(this._previousTimeout);
+		this._previousTimeout = setTimeout(() => {
+			this._liveElement.textContent = message;
+			if (typeof duration === "number") this._previousTimeout = setTimeout(() => this.clear(), duration);
+			this._currentResolve?.();
+			this._currentPromise = this._currentResolve = void 0;
+		}, 100);
+		return this._currentPromise;
+	}
+	/**
+	* Clears the current text from the announcer element. Can be used to prevent
+	* screen readers from reading the text out again while the user is going
+	* through the page landmarks.
+	*/
+	clear() {
+		if (this._liveElement) this._liveElement.textContent = "";
+	}
+	destroy() {
+		clearTimeout(this._previousTimeout);
+		this._liveElement?.remove();
+		this._liveElement = null;
+		this._currentResolve?.();
+		this._currentPromise = this._currentResolve = void 0;
+	}
+	_createLiveElement() {
+		const elementClass = "sbb-live-announcer-element";
+		const previousElements = document.getElementsByClassName(elementClass);
+		const liveEl = document.createElement("div");
+		for (let i = 0; i < previousElements.length; i++) previousElements[i].remove();
+		liveEl.classList.add(elementClass);
+		liveEl.classList.add("sbb-screen-reader-only");
+		liveEl.setAttribute("aria-atomic", "true");
+		liveEl.setAttribute("aria-live", "polite");
+		liveEl.id = `sbb-live-announcer-${uniqueIds++}`;
+		document.body.appendChild(liveEl);
+		return liveEl;
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"live-announcer.js","sources":["../../../../../src/elements/core/a11y/live-announcer.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport { isServer } from 'lit';\n\nexport type AriaLivePoliteness = 'off' | 'polite' | 'assertive';\n\nlet uniqueIds = 0;\n\n/**\n * Allows to announce messages to screen readers.\n *\n * Adapted from https://github.com/angular/components/blob/main/src/cdk/a11y/live-announcer/live-announcer.ts\n */\nexport class SbbLiveAnnouncer {\n  private _liveElement!: HTMLElement;\n  private _previousTimeout: ReturnType<typeof setTimeout> | undefined;\n  private _currentPromise: Promise<void> | undefined;\n  private _currentResolve: (() => void) | undefined;\n\n  public constructor() {\n    if (!isServer) {\n      if (document.body) {\n        this._liveElement = this._createLiveElement();\n      } else {\n        document.addEventListener('DOMContentLoaded', () => {\n          this._liveElement = this._createLiveElement();\n        });\n      }\n    }\n  }\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, politeness?: AriaLivePoliteness): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, duration?: number): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(\n    message: string,\n    politeness?: AriaLivePoliteness,\n    duration?: number,\n  ): Promise<void>;\n\n  public announce(message: string, ...args: any[]): Promise<void> {\n    // On the server or when the DOM is not ready yet, we don't do anything.\n    if (!this._liveElement) {\n      return Promise.resolve();\n    }\n\n    // TODO: Decide whether to have global options.\n    const defaultOptions = {} as { politeness?: AriaLivePoliteness; duration?: number };\n    let politeness: AriaLivePoliteness | undefined;\n    let duration: number | undefined;\n\n    if (args.length === 1 && typeof args[0] === 'number') {\n      duration = args[0];\n    } else {\n      [politeness, duration] = args;\n    }\n\n    this.clear();\n    clearTimeout(this._previousTimeout);\n\n    politeness ??= defaultOptions?.politeness ?? 'polite';\n    duration ??= defaultOptions?.duration;\n\n    this._liveElement.setAttribute('aria-live', politeness);\n\n    // This 100ms timeout is necessary for some browser + screen-reader combinations:\n    // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.\n    // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a\n    //   second time without clearing and then using a non-zero delay.\n    // (using JAWS 17 at time of this writing).\n    this._currentPromise ??= new Promise((resolve) => (this._currentResolve = resolve));\n\n    clearTimeout(this._previousTimeout);\n    this._previousTimeout = setTimeout(() => {\n      this._liveElement.textContent = message;\n\n      if (typeof duration === 'number') {\n        this._previousTimeout = setTimeout(() => this.clear(), duration);\n      }\n\n      this._currentResolve?.();\n      this._currentPromise = this._currentResolve = undefined;\n    }, 100);\n\n    return this._currentPromise;\n  }\n\n  /**\n   * Clears the current text from the announcer element. Can be used to prevent\n   * screen readers from reading the text out again while the user is going\n   * through the page landmarks.\n   */\n  public clear(): void {\n    if (this._liveElement) {\n      this._liveElement.textContent = '';\n    }\n  }\n\n  public destroy(): void {\n    clearTimeout(this._previousTimeout);\n    this._liveElement?.remove();\n    this._liveElement = null!;\n    this._currentResolve?.();\n    this._currentPromise = this._currentResolve = undefined;\n  }\n\n  private _createLiveElement(): HTMLElement {\n    const elementClass = 'sbb-live-announcer-element';\n    const previousElements = document.getElementsByClassName(elementClass);\n    const liveEl = document.createElement('div');\n\n    // Remove any old containers. This can happen when coming in from a server-side-rendered page.\n    for (let i = 0; i < previousElements.length; i++) {\n      previousElements[i].remove();\n    }\n\n    liveEl.classList.add(elementClass);\n    liveEl.classList.add('sbb-screen-reader-only');\n\n    liveEl.setAttribute('aria-atomic', 'true');\n    liveEl.setAttribute('aria-live', 'polite');\n    liveEl.id = `sbb-live-announcer-${uniqueIds++}`;\n\n    document.body.appendChild(liveEl);\n\n    return liveEl;\n  }\n}\n\nexport const sbbLiveAnnouncer = new SbbLiveAnnouncer();\n"],"names":[],"mappings":";AAYA,IAAI,YAAY;MAOH,iBAAgB;AAAA,EAM3B,cAAA;AACE,QAAI,CAAC,UAAU;AACb,UAAI,SAAS,MAAM;AACjB,aAAK,eAAe,KAAK,mBAAA;AAAA,MAC3B,OAAO;AACL,iBAAS,iBAAiB,oBAAoB,MAAK;AACjD,eAAK,eAAe,KAAK,mBAAA;AAAA,QAC3B,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAAA,EA0CO,SAAS,YAAoB,MAAW;AAE7C,QAAI,CAAC,KAAK,cAAc;AACtB,aAAO,QAAQ,QAAA;AAAA,IACjB;AAGA,UAAM,iBAAiB,CAAA;AACvB,QAAI;AACJ,QAAI;AAEJ,QAAI,KAAK,WAAW,KAAK,OAAO,KAAK,CAAC,MAAM,UAAU;AACpD,iBAAW,KAAK,CAAC;AAAA,IACnB,OAAO;AACL,OAAC,YAAY,QAAQ,IAAI;AAAA,IAC3B;AAEA,SAAK,MAAA;AACL,iBAAa,KAAK,gBAAgB;AAElC,mBAAe,gBAAgB,cAAc;AAC7C,iBAAa,gBAAgB;AAE7B,SAAK,aAAa,aAAa,aAAa,UAAU;AAOtD,SAAK,oBAAoB,IAAI,QAAQ,CAAC,YAAa,KAAK,kBAAkB,OAAQ;AAElF,iBAAa,KAAK,gBAAgB;AAClC,SAAK,mBAAmB,WAAW,MAAK;AACtC,WAAK,aAAa,cAAc;AAEhC,UAAI,OAAO,aAAa,UAAU;AAChC,aAAK,mBAAmB,WAAW,MAAM,KAAK,MAAA,GAAS,QAAQ;AAAA,MACjE;AAEA,WAAK,kBAAA;AACL,WAAK,kBAAkB,KAAK,kBAAkB;AAAA,IAChD,GAAG,GAAG;AAEN,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,QAAK;AACV,QAAI,KAAK,cAAc;AACrB,WAAK,aAAa,cAAc;AAAA,IAClC;AAAA,EACF;AAAA,EAEO,UAAO;AACZ,iBAAa,KAAK,gBAAgB;AAClC,SAAK,cAAc,OAAA;AACnB,SAAK,eAAe;AACpB,SAAK,kBAAA;AACL,SAAK,kBAAkB,KAAK,kBAAkB;AAAA,EAChD;AAAA,EAEQ,qBAAkB;AACxB,UAAM,eAAe;AACrB,UAAM,mBAAmB,SAAS,uBAAuB,YAAY;AACrE,UAAM,SAAS,SAAS,cAAc,KAAK;AAG3C,aAAS,IAAI,GAAG,IAAI,iBAAiB,QAAQ,KAAK;AAChD,uBAAiB,CAAC,EAAE,OAAA;AAAA,IACtB;AAEA,WAAO,UAAU,IAAI,YAAY;AACjC,WAAO,UAAU,IAAI,wBAAwB;AAE7C,WAAO,aAAa,eAAe,MAAM;AACzC,WAAO,aAAa,aAAa,QAAQ;AACzC,WAAO,KAAK,sBAAsB,WAAW;AAE7C,aAAS,KAAK,YAAY,MAAM;AAEhC,WAAO;AAAA,EACT;AACD;AAEM,MAAM,mBAAmB,IAAI,iBAAA;"}
+var sbbLiveAnnouncer = new SbbLiveAnnouncer();
+//#endregion
+export { SbbLiveAnnouncer, sbbLiveAnnouncer };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"live-announcer.js","names":[],"sources":["../../../../../src/elements/core/a11y/live-announcer.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport { isServer } from 'lit';\n\nexport type AriaLivePoliteness = 'off' | 'polite' | 'assertive';\n\nlet uniqueIds = 0;\n\n/**\n * Allows to announce messages to screen readers.\n *\n * Adapted from https://github.com/angular/components/blob/main/src/cdk/a11y/live-announcer/live-announcer.ts\n */\nexport class SbbLiveAnnouncer {\n  private _liveElement!: HTMLElement;\n  private _previousTimeout: ReturnType<typeof setTimeout> | undefined;\n  private _currentPromise: Promise<void> | undefined;\n  private _currentResolve: (() => void) | undefined;\n\n  public constructor() {\n    if (!isServer) {\n      if (document.body) {\n        this._liveElement = this._createLiveElement();\n      } else {\n        document.addEventListener('DOMContentLoaded', () => {\n          this._liveElement = this._createLiveElement();\n        });\n      }\n    }\n  }\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, politeness?: AriaLivePoliteness): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, duration?: number): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(\n    message: string,\n    politeness?: AriaLivePoliteness,\n    duration?: number,\n  ): Promise<void>;\n\n  public announce(message: string, ...args: any[]): Promise<void> {\n    // On the server or when the DOM is not ready yet, we don't do anything.\n    if (!this._liveElement) {\n      return Promise.resolve();\n    }\n\n    // TODO: Decide whether to have global options.\n    const defaultOptions = {} as { politeness?: AriaLivePoliteness; duration?: number };\n    let politeness: AriaLivePoliteness | undefined;\n    let duration: number | undefined;\n\n    if (args.length === 1 && typeof args[0] === 'number') {\n      duration = args[0];\n    } else {\n      [politeness, duration] = args;\n    }\n\n    this.clear();\n    clearTimeout(this._previousTimeout);\n\n    politeness ??= defaultOptions?.politeness ?? 'polite';\n    duration ??= defaultOptions?.duration;\n\n    this._liveElement.setAttribute('aria-live', politeness);\n\n    // This 100ms timeout is necessary for some browser + screen-reader combinations:\n    // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.\n    // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a\n    //   second time without clearing and then using a non-zero delay.\n    // (using JAWS 17 at time of this writing).\n    this._currentPromise ??= new Promise((resolve) => (this._currentResolve = resolve));\n\n    clearTimeout(this._previousTimeout);\n    this._previousTimeout = setTimeout(() => {\n      this._liveElement.textContent = message;\n\n      if (typeof duration === 'number') {\n        this._previousTimeout = setTimeout(() => this.clear(), duration);\n      }\n\n      this._currentResolve?.();\n      this._currentPromise = this._currentResolve = undefined;\n    }, 100);\n\n    return this._currentPromise;\n  }\n\n  /**\n   * Clears the current text from the announcer element. Can be used to prevent\n   * screen readers from reading the text out again while the user is going\n   * through the page landmarks.\n   */\n  public clear(): void {\n    if (this._liveElement) {\n      this._liveElement.textContent = '';\n    }\n  }\n\n  public destroy(): void {\n    clearTimeout(this._previousTimeout);\n    this._liveElement?.remove();\n    this._liveElement = null!;\n    this._currentResolve?.();\n    this._currentPromise = this._currentResolve = undefined;\n  }\n\n  private _createLiveElement(): HTMLElement {\n    const elementClass = 'sbb-live-announcer-element';\n    const previousElements = document.getElementsByClassName(elementClass);\n    const liveEl = document.createElement('div');\n\n    // Remove any old containers. This can happen when coming in from a server-side-rendered page.\n    for (let i = 0; i < previousElements.length; i++) {\n      previousElements[i].remove();\n    }\n\n    liveEl.classList.add(elementClass);\n    liveEl.classList.add('sbb-screen-reader-only');\n\n    liveEl.setAttribute('aria-atomic', 'true');\n    liveEl.setAttribute('aria-live', 'polite');\n    liveEl.id = `sbb-live-announcer-${uniqueIds++}`;\n\n    document.body.appendChild(liveEl);\n\n    return liveEl;\n  }\n}\n\nexport const sbbLiveAnnouncer = new SbbLiveAnnouncer();\n"],"mappings":";;;;;;;;;AAYA,IAAI,YAAY;;;;;;AAOhB,IAAa,mBAAb,MAA6B;CAM3B,cAAA;AACE,MAAI,CAAC,SACH,KAAI,SAAS,KACX,MAAK,eAAe,KAAK,oBAAoB;MAE7C,UAAS,iBAAiB,0BAAyB;AACjD,QAAK,eAAe,KAAK,oBAAoB;IAC7C;;CA6CD,SAAS,SAAiB,GAAG,MAAW;AAE7C,MAAI,CAAC,KAAK,aACR,QAAO,QAAQ,SAAS;EAI1B,MAAM,iBAAiB,EAA4D;EACnF,IAAI;EACJ,IAAI;AAEJ,MAAI,KAAK,WAAW,KAAK,OAAO,KAAK,OAAO,SAC1C,YAAW,KAAK;MAEhB,EAAC,YAAY,YAAY;AAG3B,OAAK,OAAO;AACZ,eAAa,KAAK,iBAAiB;AAEnC,iBAAe,gBAAgB,cAAc;AAC7C,eAAa,gBAAgB;AAE7B,OAAK,aAAa,aAAa,aAAa,WAAW;AAOvD,OAAK,oBAAoB,IAAI,SAAS,YAAa,KAAK,kBAAkB,QAAS;AAEnF,eAAa,KAAK,iBAAiB;AACnC,OAAK,mBAAmB,iBAAgB;AACtC,QAAK,aAAa,cAAc;AAEhC,OAAI,OAAO,aAAa,SACtB,MAAK,mBAAmB,iBAAiB,KAAK,OAAO,EAAE,SAAS;AAGlE,QAAK,mBAAmB;AACxB,QAAK,kBAAkB,KAAK,kBAAkB,KAAA;KAC7C,IAAI;AAEP,SAAO,KAAK;;;;;;;CAQP,QAAK;AACV,MAAI,KAAK,aACP,MAAK,aAAa,cAAc;;CAI7B,UAAO;AACZ,eAAa,KAAK,iBAAiB;AACnC,OAAK,cAAc,QAAQ;AAC3B,OAAK,eAAe;AACpB,OAAK,mBAAmB;AACxB,OAAK,kBAAkB,KAAK,kBAAkB,KAAA;;CAGxC,qBAAkB;EACxB,MAAM,eAAe;EACrB,MAAM,mBAAmB,SAAS,uBAAuB,aAAa;EACtE,MAAM,SAAS,SAAS,cAAc,MAAM;AAG5C,OAAK,IAAI,IAAI,GAAG,IAAI,iBAAiB,QAAQ,IAC3C,kBAAiB,GAAG,QAAQ;AAG9B,SAAO,UAAU,IAAI,aAAa;AAClC,SAAO,UAAU,IAAI,yBAAyB;AAE9C,SAAO,aAAa,eAAe,OAAO;AAC1C,SAAO,aAAa,aAAa,SAAS;AAC1C,SAAO,KAAK,sBAAsB;AAElC,WAAS,KAAK,YAAY,OAAO;AAEjC,SAAO;;;AAIX,IAAa,mBAAmB,IAAI,kBAAkB"}

package/development/core/a11y.js

@@ -1,27 +1,9 @@
 import { getNextElementIndex, isArrowKeyOrPageKeysPressed, isArrowKeyPressed, isNextArrowKeyPressed, isPreviousArrowKeyPressed } from "./a11y/arrow-navigation.js";
 import { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from "./a11y/fake-event-detection.js";
+import { sbbInputModalityDetector } from "./a11y/input-modality-detector.js";
 import { SbbFocusVisibleWithinController } from "./a11y/focus-visible-within-controller.js";
 import { IS_FOCUSABLE_QUERY } from "./a11y/focus.js";
-import { SbbFocusTrapController } from "./a11y/focus-trap-controller.js";
 import { InteractivityChecker, IsFocusableConfig, interactivityChecker } from "./a11y/interactivity-checker.js";
-import { sbbInputModalityDetector } from "./a11y/input-modality-detector.js";
+import { SbbFocusTrapController } from "./a11y/focus-trap-controller.js";
 import { SbbLiveAnnouncer, sbbLiveAnnouncer } from "./a11y/live-announcer.js";
-export {
-  IS_FOCUSABLE_QUERY,
-  InteractivityChecker,
-  IsFocusableConfig,
-  SbbFocusTrapController,
-  SbbFocusVisibleWithinController,
-  SbbLiveAnnouncer,
-  getNextElementIndex,
-  interactivityChecker,
-  isArrowKeyOrPageKeysPressed,
-  isArrowKeyPressed,
-  isFakeMousedownFromScreenReader,
-  isFakeTouchstartFromScreenReader,
-  isNextArrowKeyPressed,
-  isPreviousArrowKeyPressed,
-  sbbInputModalityDetector,
-  sbbLiveAnnouncer
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYTExeS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OyJ9
+export { IS_FOCUSABLE_QUERY, InteractivityChecker, IsFocusableConfig, SbbFocusTrapController, SbbFocusVisibleWithinController, SbbLiveAnnouncer, getNextElementIndex, interactivityChecker, isArrowKeyOrPageKeysPressed, isArrowKeyPressed, isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader, isNextArrowKeyPressed, isPreviousArrowKeyPressed, sbbInputModalityDetector, sbbLiveAnnouncer };

package/development/core/base-elements/action-base-element.js

@@ -1,44 +1,39 @@
-import { html } from "lit";
 import { SbbElement } from "./element.js";
-class SbbActionBaseElement extends SbbElement {
-  get maybeDisabled() {
-    const maybeDisabled = this;
-    return maybeDisabled.disabled || maybeDisabled.formDisabled;
-  }
-  get maybeDisabledInteractive() {
-    return this.disabledInteractive;
-  }
-  constructor() {
-    super();
-    this.internals.states.add("action");
-  }
-  connectedCallback() {
-    super.connectedCallback();
-  }
-  setupBaseEventHandlers() {
-    this.addEventListener(
-      "click",
-      (event) => {
-        if (this.maybeDisabled && !this.maybeDisabledInteractive) {
-          event.preventDefault();
-          event.stopImmediatePropagation();
-        }
-      },
-      // capture is necessary here, as this event handler needs to be executed before any other
-      // in order to stop immediate propagation in the disabled case.
-      { capture: true }
-    );
-  }
-  /** Override this method to render the component template. */
-  renderTemplate() {
-    throw new Error("Implementation needed!");
-  }
-  /** Default render method for button-like components. */
-  render() {
-    return html`<span class="sbb-action-base ${this.localName}">${this.renderTemplate()}</span>`;
-  }
-}
-export {
-  SbbActionBaseElement
+import { html } from "lit";
+//#region src/elements/core/base-elements/action-base-element.ts
+var SbbActionBaseElement = class extends SbbElement {
+	get maybeDisabled() {
+		const maybeDisabled = this;
+		return maybeDisabled.disabled || maybeDisabled.formDisabled;
+	}
+	get maybeDisabledInteractive() {
+		return this.disabledInteractive;
+	}
+	constructor() {
+		super();
+		this.internals.states.add("action");
+	}
+	connectedCallback() {
+		super.connectedCallback();
+	}
+	setupBaseEventHandlers() {
+		this.addEventListener("click", (event) => {
+			if (this.maybeDisabled && !this.maybeDisabledInteractive) {
+				event.preventDefault();
+				event.stopImmediatePropagation();
+			}
+		}, { capture: true });
+	}
+	/** Override this method to render the component template. */
+	renderTemplate() {
+		throw new Error("Implementation needed!");
+	}
+	/** Default render method for button-like components. */
+	render() {
+		return html`<span class="sbb-action-base ${this.localName}">${this.renderTemplate()}</span>`;
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//#endregion
+export { SbbActionBaseElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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