@sbb-esta/lyne-elements-dev 0.0.0 → 4.0.0-dev.1775550881

package/development/core/a11y/focus-trap-controller.d.ts

@@ -0,0 +1,35 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+export declare class SbbFocusTrapController implements ReactiveController {
+    private _host;
+    /**
+     * Whether the focus is trap is enabled.
+     * @param enabled
+     */
+    set enabled(enabled: boolean);
+    get enabled(): boolean;
+    private _abortController;
+    constructor(_host: ReactiveControllerHost & HTMLElement);
+    hostDisconnected(): void;
+    /**
+     * Focuses the element that should be focused when the focus trap is initialized.
+     * @returns Whether focus was moved successfully.
+     */
+    focusInitialElement(options?: FocusOptions): boolean;
+    /**
+     * Focuses the first tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusFirstTabbableElement(options?: FocusOptions): boolean;
+    /**
+     * Focuses the last tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusLastTabbableElement(options?: FocusOptions): boolean;
+    private _trap;
+    /** Get the first tabbable element from a DOM subtree (inclusive). */
+    private _getFirstTabbableElement;
+    /** Get the last tabbable element from a DOM subtree (inclusive). */
+    private _getLastTabbableElement;
+    private _untrap;
+}
+//# sourceMappingURL=focus-trap-controller.d.ts.map

package/development/core/a11y/focus-trap-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-trap-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/focus-trap-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAItE,qBAAa,sBAAuB,YAAW,kBAAkB;IAkB5C,OAAO,CAAC,KAAK;IAjBhC;;;OAGG;IACH,IAAW,OAAO,CAAC,OAAO,EAAE,OAAO,EAMlC;IACD,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED,OAAO,CAAC,gBAAgB,CAAgC;gBAE7B,KAAK,EAAE,sBAAsB,GAAG,WAAW;IAI/D,gBAAgB,IAAI,IAAI;IAI/B;;;OAGG;IACI,mBAAmB,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO;IAuB3D;;;OAGG;IACI,yBAAyB,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO;IAUjE;;;OAGG;IACI,wBAAwB,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO;IAUhE,OAAO,CAAC,KAAK;IA2Bb,qEAAqE;IACrE,OAAO,CAAC,wBAAwB;IA6BhC,oEAAoE;IACpE,OAAO,CAAC,uBAAuB;IAgC/B,OAAO,CAAC,OAAO;CAIhB"}

package/development/core/a11y/focus-trap-controller.js

@@ -0,0 +1,106 @@
+import { interactivityChecker } from "./interactivity-checker.js";
+//#region src/elements/core/a11y/focus-trap-controller.ts
+var SbbFocusTrapController = class {
+	/**
+	* Whether the focus is trap is enabled.
+	* @param enabled
+	*/
+	set enabled(enabled) {
+		if (enabled) this._trap();
+		else this._untrap();
+	}
+	get enabled() {
+		return !!this._abortController;
+	}
+	constructor(_host) {
+		this._host = _host;
+		this._abortController = null;
+		this._host.addController?.(this);
+	}
+	hostDisconnected() {
+		this._untrap();
+	}
+	/**
+	* Focuses the element that should be focused when the focus trap is initialized.
+	* @returns Whether focus was moved successfully.
+	*/
+	focusInitialElement(options) {
+		const redirectToElement = this._host.querySelector("[sbb-focus-initial]");
+		if (redirectToElement) {
+			if (!interactivityChecker.isFocusable(redirectToElement)) {
+				const focusableChild = this._getFirstTabbableElement(redirectToElement);
+				focusableChild?.focus(options);
+				return !!focusableChild;
+			}
+			redirectToElement.focus(options);
+			return true;
+		}
+		return this.focusFirstTabbableElement(options);
+	}
+	/**
+	* Focuses the first tabbable element within the focus trap region.
+	* @returns Whether focus was moved successfully.
+	*/
+	focusFirstTabbableElement(options) {
+		const redirectToElement = this._getFirstTabbableElement(this._host);
+		if (redirectToElement) redirectToElement.focus(options);
+		return !!redirectToElement;
+	}
+	/**
+	* Focuses the last tabbable element within the focus trap region.
+	* @returns Whether focus was moved successfully.
+	*/
+	focusLastTabbableElement(options) {
+		const redirectToElement = this._getLastTabbableElement(this._host);
+		if (redirectToElement) redirectToElement.focus(options);
+		return !!redirectToElement;
+	}
+	_trap() {
+		this._abortController = new AbortController();
+		this._host.addEventListener("keydown", (event) => {
+			if (event.key !== "Tab") return;
+			if (!event.shiftKey) {
+				const lastFocusableElement = this._getLastTabbableElement(this._host);
+				if (lastFocusableElement && event.composedPath().includes(lastFocusableElement)) {
+					this._getFirstTabbableElement(this._host)?.focus();
+					event.preventDefault();
+				}
+			} else {
+				const firstFocusableElement = this._getFirstTabbableElement(this._host);
+				if (firstFocusableElement && event.composedPath().includes(firstFocusableElement)) {
+					this._getLastTabbableElement(this._host)?.focus();
+					event.preventDefault();
+				}
+			}
+		}, { signal: this._abortController.signal });
+	}
+	/** Get the first tabbable element from a DOM subtree (inclusive). */
+	_getFirstTabbableElement(root) {
+		if (root !== this._host && interactivityChecker.isFocusable(root) && interactivityChecker.isTabbable(root)) return root;
+		const children = root.shadowRoot?.children ?? (root.localName === "slot" && root.assignedElements().length > 0 ? root.assignedElements() : root.children);
+		for (let i = 0; i < children.length; i++) {
+			const tabbableChild = children[i].nodeType === document.ELEMENT_NODE ? this._getFirstTabbableElement(children[i]) : null;
+			if (tabbableChild) return tabbableChild;
+		}
+		return null;
+	}
+	/** Get the last tabbable element from a DOM subtree (inclusive). */
+	_getLastTabbableElement(root) {
+		let result = null;
+		if (root !== this._host && interactivityChecker.isFocusable(root) && interactivityChecker.isTabbable(root)) result = root;
+		const children = root.shadowRoot?.children ?? (root.localName === "slot" && root.assignedElements().length > 0 ? root.assignedElements() : root.children);
+		for (let i = children.length - 1; i >= 0; i--) {
+			const tabbableChild = children[i].nodeType === document.ELEMENT_NODE ? this._getLastTabbableElement(children[i]) : null;
+			if (tabbableChild) return tabbableChild;
+		}
+		return result;
+	}
+	_untrap() {
+		this._abortController?.abort();
+		this._abortController = null;
+	}
+};
+//#endregion
+export { SbbFocusTrapController };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"focus-trap-controller.js","names":[],"sources":["../../../../../src/elements/core/a11y/focus-trap-controller.ts"],"sourcesContent":["import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nimport { interactivityChecker } from './interactivity-checker.ts';\n\nexport class SbbFocusTrapController implements ReactiveController {\n  /**\n   * Whether the focus is trap is enabled.\n   * @param enabled\n   */\n  public set enabled(enabled: boolean) {\n    if (enabled) {\n      this._trap();\n    } else {\n      this._untrap();\n    }\n  }\n  public get enabled(): boolean {\n    return !!this._abortController;\n  }\n\n  private _abortController: AbortController | null = null;\n\n  public constructor(private _host: ReactiveControllerHost & HTMLElement) {\n    this._host.addController?.(this);\n  }\n\n  public hostDisconnected(): void {\n    this._untrap();\n  }\n\n  /**\n   * Focuses the element that should be focused when the focus trap is initialized.\n   * @returns Whether focus was moved successfully.\n   */\n  public focusInitialElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._host.querySelector<HTMLElement>('[sbb-focus-initial]');\n\n    if (redirectToElement) {\n      // Warn the consumer if the element they've pointed to\n      // isn't focusable, when not in production mode.\n      if (import.meta.env.DEV && !interactivityChecker.isFocusable(redirectToElement)) {\n        console.warn(`Element matching '[sbb-focus-initial]' is not focusable.`, redirectToElement);\n      }\n\n      if (!interactivityChecker.isFocusable(redirectToElement)) {\n        const focusableChild = this._getFirstTabbableElement(redirectToElement);\n        focusableChild?.focus(options);\n        return !!focusableChild;\n      }\n\n      redirectToElement.focus(options);\n      return true;\n    }\n\n    return this.focusFirstTabbableElement(options);\n  }\n\n  /**\n   * Focuses the first tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  public focusFirstTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getFirstTabbableElement(this._host);\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  /**\n   * Focuses the last tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  public focusLastTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getLastTabbableElement(this._host);\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  private _trap(): void {\n    this._abortController = new AbortController();\n    this._host.addEventListener(\n      'keydown',\n      (event) => {\n        if (event.key !== 'Tab') {\n          return;\n        }\n\n        if (!event.shiftKey) {\n          const lastFocusableElement = this._getLastTabbableElement(this._host);\n          if (lastFocusableElement && event.composedPath().includes(lastFocusableElement)) {\n            this._getFirstTabbableElement(this._host)?.focus();\n            event.preventDefault();\n          }\n        } else {\n          const firstFocusableElement = this._getFirstTabbableElement(this._host);\n          if (firstFocusableElement && event.composedPath().includes(firstFocusableElement)) {\n            this._getLastTabbableElement(this._host)?.focus();\n            event.preventDefault();\n          }\n        }\n      },\n      { signal: this._abortController.signal },\n    );\n  }\n\n  /** Get the first tabbable element from a DOM subtree (inclusive). */\n  private _getFirstTabbableElement(root: HTMLElement): HTMLElement | null {\n    if (\n      root !== this._host &&\n      interactivityChecker.isFocusable(root) &&\n      interactivityChecker.isTabbable(root)\n    ) {\n      return root;\n    }\n\n    const children =\n      root.shadowRoot?.children ??\n      (root.localName === 'slot' && (root as HTMLSlotElement).assignedElements().length > 0\n        ? (root as HTMLSlotElement).assignedElements()\n        : root.children);\n\n    for (let i = 0; i < children.length; i++) {\n      const tabbableChild =\n        children[i].nodeType === document.ELEMENT_NODE\n          ? this._getFirstTabbableElement(children[i] as HTMLElement)\n          : null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return null;\n  }\n\n  /** Get the last tabbable element from a DOM subtree (inclusive). */\n  private _getLastTabbableElement(root: HTMLElement): HTMLElement | null {\n    let result: HTMLElement | null = null;\n\n    if (\n      root !== this._host &&\n      interactivityChecker.isFocusable(root) &&\n      interactivityChecker.isTabbable(root)\n    ) {\n      result = root;\n    }\n\n    const children =\n      root.shadowRoot?.children ??\n      (root.localName === 'slot' && (root as HTMLSlotElement).assignedElements().length > 0\n        ? (root as HTMLSlotElement).assignedElements()\n        : root.children);\n\n    // Iterate in reverse DOM order.\n    for (let i = children.length - 1; i >= 0; i--) {\n      const tabbableChild =\n        children[i].nodeType === document.ELEMENT_NODE\n          ? this._getLastTabbableElement(children[i] as HTMLElement)\n          : null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return result;\n  }\n\n  private _untrap(): void {\n    this._abortController?.abort();\n    this._abortController = null;\n  }\n}\n"],"mappings":";;AAIA,IAAa,yBAAb,MAAmC;;;;;CAKjC,IAAW,QAAQ,SAAgB;AACjC,MAAI,QACF,MAAK,OAAO;MAEZ,MAAK,SAAS;;CAGlB,IAAW,UAAO;AAChB,SAAO,CAAC,CAAC,KAAK;;CAKhB,YAA2B,OAA2C;AAA3C,OAAA,QAAA;AAFnB,OAAA,mBAA2C;AAGjD,OAAK,MAAM,gBAAgB,KAAK;;CAG3B,mBAAgB;AACrB,OAAK,SAAS;;;;;;CAOT,oBAAoB,SAAsB;EAC/C,MAAM,oBAAoB,KAAK,MAAM,cAA2B,sBAAsB;AAEtF,MAAI,mBAAmB;AAOrB,OAAI,CAAC,qBAAqB,YAAY,kBAAkB,EAAE;IACxD,MAAM,iBAAiB,KAAK,yBAAyB,kBAAkB;AACvE,oBAAgB,MAAM,QAAQ;AAC9B,WAAO,CAAC,CAAC;;AAGX,qBAAkB,MAAM,QAAQ;AAChC,UAAO;;AAGT,SAAO,KAAK,0BAA0B,QAAQ;;;;;;CAOzC,0BAA0B,SAAsB;EACrD,MAAM,oBAAoB,KAAK,yBAAyB,KAAK,MAAM;AAEnE,MAAI,kBACF,mBAAkB,MAAM,QAAQ;AAGlC,SAAO,CAAC,CAAC;;;;;;CAOJ,yBAAyB,SAAsB;EACpD,MAAM,oBAAoB,KAAK,wBAAwB,KAAK,MAAM;AAElE,MAAI,kBACF,mBAAkB,MAAM,QAAQ;AAGlC,SAAO,CAAC,CAAC;;CAGH,QAAK;AACX,OAAK,mBAAmB,IAAI,iBAAiB;AAC7C,OAAK,MAAM,iBACT,YACC,UAAS;AACR,OAAI,MAAM,QAAQ,MAChB;AAGF,OAAI,CAAC,MAAM,UAAU;IACnB,MAAM,uBAAuB,KAAK,wBAAwB,KAAK,MAAM;AACrE,QAAI,wBAAwB,MAAM,cAAc,CAAC,SAAS,qBAAqB,EAAE;AAC/E,UAAK,yBAAyB,KAAK,MAAM,EAAE,OAAO;AAClD,WAAM,gBAAgB;;UAEnB;IACL,MAAM,wBAAwB,KAAK,yBAAyB,KAAK,MAAM;AACvE,QAAI,yBAAyB,MAAM,cAAc,CAAC,SAAS,sBAAsB,EAAE;AACjF,UAAK,wBAAwB,KAAK,MAAM,EAAE,OAAO;AACjD,WAAM,gBAAgB;;;KAI5B,EAAE,QAAQ,KAAK,iBAAiB,QAAQ,CACzC;;;CAIK,yBAAyB,MAAiB;AAChD,MACE,SAAS,KAAK,SACd,qBAAqB,YAAY,KAAK,IACtC,qBAAqB,WAAW,KAAK,CAErC,QAAO;EAGT,MAAM,WACJ,KAAK,YAAY,aAChB,KAAK,cAAc,UAAW,KAAyB,kBAAkB,CAAC,SAAS,IAC/E,KAAyB,kBAAkB,GAC5C,KAAK;AAEX,OAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;GACxC,MAAM,gBACJ,SAAS,GAAG,aAAa,SAAS,eAC9B,KAAK,yBAAyB,SAAS,GAAkB,GACzD;AAEN,OAAI,cACF,QAAO;;AAIX,SAAO;;;CAID,wBAAwB,MAAiB;EAC/C,IAAI,SAA6B;AAEjC,MACE,SAAS,KAAK,SACd,qBAAqB,YAAY,KAAK,IACtC,qBAAqB,WAAW,KAAK,CAErC,UAAS;EAGX,MAAM,WACJ,KAAK,YAAY,aAChB,KAAK,cAAc,UAAW,KAAyB,kBAAkB,CAAC,SAAS,IAC/E,KAAyB,kBAAkB,GAC5C,KAAK;AAGX,OAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;GAC7C,MAAM,gBACJ,SAAS,GAAG,aAAa,SAAS,eAC9B,KAAK,wBAAwB,SAAS,GAAkB,GACxD;AAEN,OAAI,cACF,QAAO;;AAIX,SAAO;;CAGD,UAAO;AACb,OAAK,kBAAkB,OAAO;AAC9B,OAAK,mBAAmB"}

package/development/core/a11y/focus-visible-within-controller.d.ts

@@ -0,0 +1,11 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+import { SbbElementInternalsMixinType } from '../mixins.ts';
+export declare class SbbFocusVisibleWithinController implements ReactiveController {
+    private _host;
+    constructor(_host: SbbElementInternalsMixinType & ReactiveControllerHost & HTMLElement);
+    private _focusinHandler;
+    private _focusoutHandler;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+//# sourceMappingURL=focus-visible-within-controller.d.ts.map

package/development/core/a11y/focus-visible-within-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-visible-within-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/focus-visible-within-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAGtE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAC;AAKjE,qBAAa,+BAAgC,YAAW,kBAAkB;IAEtE,OAAO,CAAC,KAAK;gBAAL,KAAK,EAAE,4BAA4B,GAAG,sBAAsB,GAAG,WAAW;IAKpF,OAAO,CAAC,eAAe,CAKrB;IAEF,OAAO,CAAC,gBAAgB,CAEtB;IAEK,aAAa,IAAI,IAAI;IAKrB,gBAAgB,IAAI,IAAI;CAIhC"}

package/development/core/a11y/focus-visible-within-controller.js

@@ -0,0 +1,27 @@
+import { sbbInputModalityDetector } from "./input-modality-detector.js";
+import { ɵstateController } from "../mixins/element-internals-mixin.js";
+//#region src/elements/core/a11y/focus-visible-within-controller.ts
+var SbbFocusVisibleWithinController = class {
+	constructor(_host) {
+		this._host = _host;
+		this._focusinHandler = () => {
+			ɵstateController(this._host).toggle("has-visible-focus-within", sbbInputModalityDetector.mostRecentModality === "keyboard");
+		};
+		this._focusoutHandler = () => {
+			ɵstateController(this._host).delete("has-visible-focus-within");
+		};
+		this._host.addController(this);
+	}
+	hostConnected() {
+		this._host.addEventListener("focusin", this._focusinHandler);
+		this._host.addEventListener("focusout", this._focusoutHandler);
+	}
+	hostDisconnected() {
+		this._host.removeEventListener("focusin", this._focusinHandler);
+		this._host.removeEventListener("focusout", this._focusoutHandler);
+	}
+};
+//#endregion
+export { SbbFocusVisibleWithinController };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/a11y/focus.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_FOCUSABLE_QUERY: string;
+//# sourceMappingURL=focus.d.ts.map

package/development/core/a11y/focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/focus.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,QAWnB,CAAC"}

package/development/core/a11y/focus.js

@@ -0,0 +1,15 @@
+//#region src/elements/core/a11y/focus.ts
+var IS_FOCUSABLE_QUERY = [
+	"button",
+	"[href]",
+	"input",
+	"select",
+	"textarea",
+	"details",
+	"summary",
+	"[tabindex]"
+].map((selector) => `${selector}:not([disabled],:disabled,[tabindex="-1"],[inert])`).join(",");
+//#endregion
+export { IS_FOCUSABLE_QUERY };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2NvcmUvYTExeS9mb2N1cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgSVNfRk9DVVNBQkxFX1FVRVJZID0gW1xuICAnYnV0dG9uJyxcbiAgJ1tocmVmXScsXG4gICdpbnB1dCcsXG4gICdzZWxlY3QnLFxuICAndGV4dGFyZWEnLFxuICAnZGV0YWlscycsXG4gICdzdW1tYXJ5JyxcbiAgJ1t0YWJpbmRleF0nLFxuXVxuICAubWFwKChzZWxlY3RvcikgPT4gYCR7c2VsZWN0b3J9Om5vdChbZGlzYWJsZWRdLDpkaXNhYmxlZCxbdGFiaW5kZXg9XCItMVwiXSxbaW5lcnRdKWApXG4gIC5qb2luKCcsJyk7XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxJQUFhLHFCQUFxQjtDQUNoQztDQUNBO0NBQ0E7Q0FDQTtDQUNBO0NBQ0E7Q0FDQTtDQUNBO0NBQ0QsQ0FDRSxLQUFLLGFBQWEsR0FBRyxTQUFRLG9EQUFxRCxDQUNsRixLQUFLLElBQUkifQ==

package/development/core/a11y/input-modality-detector.d.ts

@@ -0,0 +1,58 @@
+export type SbbInputModality = 'touch' | 'mouse' | 'keyboard' | 'program' | null;
+/**
+ * Service that detects the user's input modality.
+ *
+ * This service does not update the input modality when a user navigates with a screen reader
+ * (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC
+ * cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not
+ * fire as expected in these modes) but is also arguably the correct behavior. Navigating with a
+ * screen reader is akin to visually scanning a page, and should not be interpreted as actual user
+ * input interaction.
+ *
+ * When a user is not navigating but *interacting* with a screen reader, this service attempts to
+ * update the input modality to keyboard, but in general this service's behavior is largely
+ * undefined.
+ */
+declare class SbbInputModalityDetector {
+    /** The most recently detected input modality. */
+    get mostRecentModality(): SbbInputModality | null;
+    /**
+     * The most recent modality must be initialised with the value 'mouse' to cover the case where an action is
+     * performed but no mouse or keyboard event has yet occurred on the page (e.g. `sbb-popover` with hover trigger).
+     */
+    private _mostRecentModality;
+    /**
+     * The most recently detected input modality event target. Is null if no input modality has been
+     * detected or if the associated event target is null for some unknown reason.
+     */
+    get mostRecentTarget(): HTMLElement | null;
+    private _mostRecentTarget;
+    /** Options for this SbbInputModalityDetector. */
+    private readonly _options;
+    /**
+     * The timestamp of the last touch input modality. Used to determine whether mousedown events
+     * should be attributed to mouse or touch.
+     */
+    private _lastTouchMs;
+    constructor();
+    reset(): void;
+    /**
+     * Handles keydown events. Must be an arrow function in order to preserve the context when it gets
+     * bound.
+     */
+    private _onKeydown;
+    /**
+     * Handles mousedown events. Must be an arrow function in order to preserve the context when it
+     * gets bound.
+     */
+    private _onMousedown;
+    /**
+     * Handles touchstart events. Must be an arrow function in order to preserve the context when it
+     * gets bound.
+     */
+    private _onTouchstart;
+    private _updateState;
+}
+export declare const sbbInputModalityDetector: SbbInputModalityDetector;
+export {};
+//# sourceMappingURL=input-modality-detector.d.ts.map

package/development/core/a11y/input-modality-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-modality-detector.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/input-modality-detector.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,IAAI,CAAC;AAmDjF;;;;;;;;;;;;;GAaG;AACH,cAAM,wBAAwB;IAC5B,iDAAiD;IACjD,IAAW,kBAAkB,IAAI,gBAAgB,GAAG,IAAI,CAEvD;IAED;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAoC;IAE/D;;;OAGG;IACH,IAAW,gBAAgB,IAAI,WAAW,GAAG,IAAI,CAEhD;IACD,OAAO,CAAC,iBAAiB,CAA4B;IAErD,iDAAiD;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAEvB;IAEF;;;OAGG;IACH,OAAO,CAAC,YAAY,CAAK;;IAUlB,KAAK,IAAI,IAAI;IAKpB;;;OAGG;IACH,OAAO,CAAC,UAAU,CAQhB;IAEF;;;OAGG;IACH,OAAO,CAAC,YAAY,CAWlB;IAEF;;;OAGG;IACH,OAAO,CAAC,aAAa,CAanB;IAEF,OAAO,CAAC,YAAY;CAQrB;AAED,eAAO,MAAM,wBAAwB,0BAAiC,CAAC"}

package/development/core/a11y/input-modality-detector.js

@@ -0,0 +1,132 @@
+import { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from "./fake-event-detection.js";
+import { isServer } from "lit";
+import { getEventTarget } from "../eventing.js";
+//#region src/elements/core/a11y/input-modality-detector.ts
+/**
+* Default options for the SbbInputModalityDetector.
+*
+* Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect
+* keyboard input modality) for two reasons:
+*
+* 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open
+*    in new tab', and are thus less representative of actual keyboard interaction.
+* 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but
+*    confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore
+*    these keys so, as to not update the input modality.
+*
+* Note that we do not by default ignore the right Meta key on Safari because it has the same key
+* code as the ContextMenu key on other browsers. When we switch to using event.key, we can
+* distinguish between the two.
+*/
+var inputModalityDetectorOptions = { ignoreKeys: [
+	18,
+	17,
+	224,
+	91,
+	16
+] };
+/**
+* The amount of time needed to pass after a touchstart event in order for a subsequent mousedown
+* event to be attributed as mouse and not touch.
+*
+* Through trial and error it was found that a value of around 650ms seems appropriate.
+*/
+var touchBufferMs = 650;
+/**
+* Event listener options that enable capturing and also mark the listener as passive if the browser
+* supports it.
+*/
+var modalityEventListenerOptions = {
+	passive: true,
+	capture: true
+};
+/**
+* Service that detects the user's input modality.
+*
+* This service does not update the input modality when a user navigates with a screen reader
+* (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC
+* cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not
+* fire as expected in these modes) but is also arguably the correct behavior. Navigating with a
+* screen reader is akin to visually scanning a page, and should not be interpreted as actual user
+* input interaction.
+*
+* When a user is not navigating but *interacting* with a screen reader, this service attempts to
+* update the input modality to keyboard, but in general this service's behavior is largely
+* undefined.
+*/
+var SbbInputModalityDetector = class {
+	/** The most recently detected input modality. */
+	get mostRecentModality() {
+		return this._mostRecentModality;
+	}
+	/**
+	* The most recently detected input modality event target. Is null if no input modality has been
+	* detected or if the associated event target is null for some unknown reason.
+	*/
+	get mostRecentTarget() {
+		return this._mostRecentTarget;
+	}
+	constructor() {
+		/**
+		* The most recent modality must be initialised with the value 'mouse' to cover the case where an action is
+		* performed but no mouse or keyboard event has yet occurred on the page (e.g. `sbb-popover` with hover trigger).
+		*/
+		this._mostRecentModality = "mouse";
+		this._mostRecentTarget = null;
+		/** Options for this SbbInputModalityDetector. */
+		this._options = { ...inputModalityDetectorOptions };
+		/**
+		* The timestamp of the last touch input modality. Used to determine whether mousedown events
+		* should be attributed to mouse or touch.
+		*/
+		this._lastTouchMs = 0;
+		/**
+		* Handles keydown events. Must be an arrow function in order to preserve the context when it gets
+		* bound.
+		*/
+		this._onKeydown = (event) => {
+			if (this._options?.ignoreKeys?.some((keyCode) => keyCode === event.keyCode)) return;
+			this._updateState("keyboard", event);
+		};
+		/**
+		* Handles mousedown events. Must be an arrow function in order to preserve the context when it
+		* gets bound.
+		*/
+		this._onMousedown = (event) => {
+			if (Date.now() - this._lastTouchMs < touchBufferMs) return;
+			this._updateState(isFakeMousedownFromScreenReader(event) ? "keyboard" : "mouse", event);
+		};
+		/**
+		* Handles touchstart events. Must be an arrow function in order to preserve the context when it
+		* gets bound.
+		*/
+		this._onTouchstart = (event) => {
+			if (isFakeTouchstartFromScreenReader(event)) {
+				this._updateState("keyboard", event);
+				return;
+			}
+			this._lastTouchMs = Date.now();
+			this._updateState("touch", event);
+		};
+		if (!isServer) {
+			document.addEventListener("keydown", this._onKeydown, modalityEventListenerOptions);
+			document.addEventListener("mousedown", this._onMousedown, modalityEventListenerOptions);
+			document.addEventListener("touchstart", this._onTouchstart, modalityEventListenerOptions);
+		}
+	}
+	reset() {
+		this._updateState("mouse", null);
+		this._lastTouchMs = 0;
+	}
+	_updateState(modality, event) {
+		if (this._mostRecentModality) document.documentElement.classList.remove(`sbb-focus-modality-${this._mostRecentModality}`);
+		this._mostRecentModality = modality;
+		this._mostRecentTarget = event ? getEventTarget(event) : null;
+		document.documentElement.classList.add(`sbb-focus-modality-${this._mostRecentModality}`);
+	}
+};
+var sbbInputModalityDetector = new SbbInputModalityDetector();
+//#endregion
+export { sbbInputModalityDetector };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"input-modality-detector.js","names":[],"sources":["../../../../../src/elements/core/a11y/input-modality-detector.ts"],"sourcesContent":["// This implementation is inspired by https://github.com/angular/components/blob/main/src/cdk/a11y/input-modality/input-modality-detector.ts\n\nimport { isServer } from 'lit';\n\nimport { getEventTarget } from '../eventing.ts';\n\nimport {\n  isFakeMousedownFromScreenReader,\n  isFakeTouchstartFromScreenReader,\n} from './fake-event-detection.ts';\n\nexport type SbbInputModality = 'touch' | 'mouse' | 'keyboard' | 'program' | null;\n\n/** Options to configure the behavior of the SbbInputModalityDetector. */\ninterface SbbInputModalityDetectorOptions {\n  /** Keys to ignore when detecting keyboard input modality. */\n  ignoreKeys?: number[];\n}\n\nconst SHIFT = 16;\nconst CONTROL = 17;\nconst ALT = 18;\nconst META = 91; // WIN_KEY_LEFT\nconst MAC_META = 224;\n\n/**\n * Default options for the SbbInputModalityDetector.\n *\n * Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect\n * keyboard input modality) for two reasons:\n *\n * 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open\n *    in new tab', and are thus less representative of actual keyboard interaction.\n * 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but\n *    confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore\n *    these keys so, as to not update the input modality.\n *\n * Note that we do not by default ignore the right Meta key on Safari because it has the same key\n * code as the ContextMenu key on other browsers. When we switch to using event.key, we can\n * distinguish between the two.\n */\nconst inputModalityDetectorOptions: SbbInputModalityDetectorOptions = {\n  ignoreKeys: [ALT, CONTROL, MAC_META, META, SHIFT],\n};\n\n/**\n * The amount of time needed to pass after a touchstart event in order for a subsequent mousedown\n * event to be attributed as mouse and not touch.\n *\n * Through trial and error it was found that a value of around 650ms seems appropriate.\n */\nconst touchBufferMs = 650;\n\n/**\n * Event listener options that enable capturing and also mark the listener as passive if the browser\n * supports it.\n */\nconst modalityEventListenerOptions = {\n  passive: true,\n  capture: true,\n};\n\n/**\n * Service that detects the user's input modality.\n *\n * This service does not update the input modality when a user navigates with a screen reader\n * (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC\n * cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not\n * fire as expected in these modes) but is also arguably the correct behavior. Navigating with a\n * screen reader is akin to visually scanning a page, and should not be interpreted as actual user\n * input interaction.\n *\n * When a user is not navigating but *interacting* with a screen reader, this service attempts to\n * update the input modality to keyboard, but in general this service's behavior is largely\n * undefined.\n */\nclass SbbInputModalityDetector {\n  /** The most recently detected input modality. */\n  public get mostRecentModality(): SbbInputModality | null {\n    return this._mostRecentModality;\n  }\n\n  /**\n   * The most recent modality must be initialised with the value 'mouse' to cover the case where an action is\n   * performed but no mouse or keyboard event has yet occurred on the page (e.g. `sbb-popover` with hover trigger).\n   */\n  private _mostRecentModality: SbbInputModality | null = 'mouse';\n\n  /**\n   * The most recently detected input modality event target. Is null if no input modality has been\n   * detected or if the associated event target is null for some unknown reason.\n   */\n  public get mostRecentTarget(): HTMLElement | null {\n    return this._mostRecentTarget;\n  }\n  private _mostRecentTarget: HTMLElement | null = null;\n\n  /** Options for this SbbInputModalityDetector. */\n  private readonly _options: SbbInputModalityDetectorOptions = {\n    ...inputModalityDetectorOptions,\n  };\n\n  /**\n   * The timestamp of the last touch input modality. Used to determine whether mousedown events\n   * should be attributed to mouse or touch.\n   */\n  private _lastTouchMs = 0;\n\n  public constructor() {\n    if (!isServer) {\n      document.addEventListener('keydown', this._onKeydown, modalityEventListenerOptions);\n      document.addEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);\n      document.addEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);\n    }\n  }\n\n  public reset(): void {\n    this._updateState('mouse', null);\n    this._lastTouchMs = 0;\n  }\n\n  /**\n   * Handles keydown events. Must be an arrow function in order to preserve the context when it gets\n   * bound.\n   */\n  private _onKeydown = (event: KeyboardEvent): void => {\n    // If this is one of the keys we should ignore, then ignore it and don't update the input\n    // modality to keyboard.\n    if (this._options?.ignoreKeys?.some((keyCode) => keyCode === event.keyCode)) {\n      return;\n    }\n\n    this._updateState('keyboard', event);\n  };\n\n  /**\n   * Handles mousedown events. Must be an arrow function in order to preserve the context when it\n   * gets bound.\n   */\n  private _onMousedown = (event: MouseEvent): void => {\n    // Touches trigger both touch and mouse events, so we need to distinguish between mouse events\n    // that were triggered via mouse vs touch. To do so, check if the mouse event occurs closely\n    // after the previous touch event.\n    if (Date.now() - this._lastTouchMs < touchBufferMs) {\n      return;\n    }\n\n    // Fake mousedown events are fired by some screen readers when controls are activated by the\n    // screen reader. Attribute them to keyboard input modality.\n    this._updateState(isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse', event);\n  };\n\n  /**\n   * Handles touchstart events. Must be an arrow function in order to preserve the context when it\n   * gets bound.\n   */\n  private _onTouchstart = (event: TouchEvent): void => {\n    // Same scenario as mentioned in _onMousedown, but on touch screen devices, fake touchstart\n    // events are fired. Again, attribute to keyboard input modality.\n    if (isFakeTouchstartFromScreenReader(event)) {\n      this._updateState('keyboard', event);\n      return;\n    }\n\n    // Store the timestamp of this touch event, as it's used to distinguish between mouse events\n    // triggered via mouse vs touch.\n    this._lastTouchMs = Date.now();\n\n    this._updateState('touch', event);\n  };\n\n  private _updateState(modality: SbbInputModality, event: Event | null): void {\n    if (this._mostRecentModality) {\n      document.documentElement.classList.remove(`sbb-focus-modality-${this._mostRecentModality}`);\n    }\n    this._mostRecentModality = modality;\n    this._mostRecentTarget = event ? getEventTarget(event) : null;\n    document.documentElement.classList.add(`sbb-focus-modality-${this._mostRecentModality}`);\n  }\n}\n\nexport const sbbInputModalityDetector = new SbbInputModalityDetector();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyCA,IAAM,+BAAgE,EACpE,YAAY;CArBF;CADI;CAGC;CADJ;CAHC;CAuBqC,EAClD;;;;;;;AAQD,IAAM,gBAAgB;;;;;AAMtB,IAAM,+BAA+B;CACnC,SAAS;CACT,SAAS;CACV;;;;;;;;;;;;;;;AAgBD,IAAM,2BAAN,MAA8B;;CAE5B,IAAW,qBAAkB;AAC3B,SAAO,KAAK;;;;;;CAad,IAAW,mBAAgB;AACzB,SAAO,KAAK;;CAed,cAAA;;;;;AAtBQ,OAAA,sBAA+C;AAS/C,OAAA,oBAAwC;;AAG/B,OAAA,WAA4C,EAC3D,GAAG,8BACJ;;;;;AAMO,OAAA,eAAe;;;;;AAmBf,OAAA,cAAc,UAA8B;AAGlD,OAAI,KAAK,UAAU,YAAY,MAAM,YAAY,YAAY,MAAM,QAAQ,CACzE;AAGF,QAAK,aAAa,YAAY,MAAM;;;;;;AAO9B,OAAA,gBAAgB,UAA2B;AAIjD,OAAI,KAAK,KAAK,GAAG,KAAK,eAAe,cACnC;AAKF,QAAK,aAAa,gCAAgC,MAAM,GAAG,aAAa,SAAS,MAAM;;;;;;AAOjF,OAAA,iBAAiB,UAA2B;AAGlD,OAAI,iCAAiC,MAAM,EAAE;AAC3C,SAAK,aAAa,YAAY,MAAM;AACpC;;AAKF,QAAK,eAAe,KAAK,KAAK;AAE9B,QAAK,aAAa,SAAS,MAAM;;AA3DjC,MAAI,CAAC,UAAU;AACb,YAAS,iBAAiB,WAAW,KAAK,YAAY,6BAA6B;AACnF,YAAS,iBAAiB,aAAa,KAAK,cAAc,6BAA6B;AACvF,YAAS,iBAAiB,cAAc,KAAK,eAAe,6BAA6B;;;CAItF,QAAK;AACV,OAAK,aAAa,SAAS,KAAK;AAChC,OAAK,eAAe;;CAqDd,aAAa,UAA4B,OAAmB;AAClE,MAAI,KAAK,oBACP,UAAS,gBAAgB,UAAU,OAAO,sBAAsB,KAAK,sBAAsB;AAE7F,OAAK,sBAAsB;AAC3B,OAAK,oBAAoB,QAAQ,eAAe,MAAM,GAAG;AACzD,WAAS,gBAAgB,UAAU,IAAI,sBAAsB,KAAK,sBAAsB;;;AAI5F,IAAa,2BAA2B,IAAI,0BAA0B"}

package/development/core/a11y/interactivity-checker.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @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.io/license
+ */
+/**
+ * Configuration for the isFocusable method.
+ */
+export declare class IsFocusableConfig {
+    /**
+     * Whether to count an element as focusable even if it is not currently visible.
+     */
+    ignoreVisibility: boolean;
+}
+export declare class InteractivityChecker {
+    /**
+     * Gets whether an element is disabled.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is disabled.
+     */
+    isDisabled(element: HTMLElement): boolean;
+    /**
+     * Gets whether an element is visible for the purposes of interactivity.
+     *
+     * This will capture states like `display: none` and `visibility: hidden`, but not things like
+     * being clipped by an `overflow: hidden` parent or being outside the viewport.
+     *
+     * @returns Whether the element is visible.
+     */
+    isVisible(element: HTMLElement): boolean;
+    /**
+     * Gets whether an element can be reached via Tab key.
+     * Assumes that the element has already been checked with isFocusable.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is tabbable.
+     */
+    isTabbable(element: HTMLElement): boolean;
+    /**
+     * Gets whether an element can be focused by the user.
+     *
+     * @param element Element to be checked.
+     * @param config The config object with options to customize this method's behavior
+     * @returns Whether the element is focusable.
+     */
+    isFocusable(element: HTMLElement, config?: IsFocusableConfig): boolean;
+}
+export declare const interactivityChecker: InteractivityChecker;
+//# sourceMappingURL=interactivity-checker.d.ts.map

package/development/core/a11y/interactivity-checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactivity-checker.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/interactivity-checker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH;;GAEG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;IACI,gBAAgB,EAAE,OAAO,CAAS;CAC1C;AAED,qBAAa,oBAAoB;IAC/B;;;;;OAKG;IACI,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO;IAIhD;;;;;;;OAOG;IACI,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO;IAI/C;;;;;;OAMG;IACI,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO;IA0DhD;;;;;;OAMG;IACI,WAAW,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,iBAAiB,GAAG,OAAO;CAU9E;AAID,eAAO,MAAM,oBAAoB,sBAA6B,CAAC"}