@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771859294

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

@@ -0,0 +1,122 @@
+import { interactivityChecker } from "./interactivity-checker.js";
+class SbbFocusTrapController {
+  /**
+   * 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 ? root.shadowRoot.children : root.localName === "slot" ? 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 ? root.shadowRoot.children : root.localName === "slot" ? 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;
+  }
+}
+export {
+  SbbFocusTrapController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"focus-trap-controller.js","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 = root.shadowRoot\n      ? root.shadowRoot.children\n      : root.localName === 'slot'\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 = root.shadowRoot\n      ? root.shadowRoot.children\n      : root.localName === 'slot'\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"],"names":[],"mappings":"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"}

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,26 @@
+import { ɵstateController as _stateController } from "../mixins/element-internals-mixin.js";
+import { sbbInputModalityDetector } from "./input-modality-detector.js";
+class SbbFocusVisibleWithinController {
+  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);
+  }
+}
+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,14 @@
+const IS_FOCUSABLE_QUERY = [
+  "button",
+  "[href]",
+  "input",
+  "select",
+  "textarea",
+  "details",
+  "summary",
+  "[tabindex]"
+].map((selector) => `${selector}:not([disabled],:disabled,[tabindex="-1"],[inert])`).join(",");
+export {
+  IS_FOCUSABLE_QUERY
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9jb3JlL2ExMXkvZm9jdXMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IElTX0ZPQ1VTQUJMRV9RVUVSWSA9IFtcbiAgJ2J1dHRvbicsXG4gICdbaHJlZl0nLFxuICAnaW5wdXQnLFxuICAnc2VsZWN0JyxcbiAgJ3RleHRhcmVhJyxcbiAgJ2RldGFpbHMnLFxuICAnc3VtbWFyeScsXG4gICdbdGFiaW5kZXhdJyxcbl1cbiAgLm1hcCgoc2VsZWN0b3IpID0+IGAke3NlbGVjdG9yfTpub3QoW2Rpc2FibGVkXSw6ZGlzYWJsZWQsW3RhYmluZGV4PVwiLTFcIl0sW2luZXJ0XSlgKVxuICAuam9pbignLCcpO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFPLE1BQU0scUJBQXFCO0FBQUEsRUFDaEM7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQ0QsRUFDRSxJQUFJLENBQUMsYUFBYSxHQUFHLFFBQVEsb0RBQW9ELEVBQ2pGLEtBQUssR0FBRzsifQ==

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,79 @@
+import { isServer } from "lit";
+import { getEventTarget } from "../eventing.js";
+import { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from "./fake-event-detection.js";
+const SHIFT = 16;
+const CONTROL = 17;
+const ALT = 18;
+const META = 91;
+const MAC_META = 224;
+const inputModalityDetectorOptions = {
+  ignoreKeys: [ALT, CONTROL, MAC_META, META, SHIFT]
+};
+const touchBufferMs = 650;
+const modalityEventListenerOptions = {
+  passive: true,
+  capture: true
+};
+class SbbInputModalityDetector {
+  /** 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() {
+    this._mostRecentModality = "mouse";
+    this._mostRecentTarget = null;
+    this._options = {
+      ...inputModalityDetectorOptions
+    };
+    this._lastTouchMs = 0;
+    this._onKeydown = (event) => {
+      if (this._options?.ignoreKeys?.some((keyCode) => keyCode === event.keyCode)) {
+        return;
+      }
+      this._updateState("keyboard", event);
+    };
+    this._onMousedown = (event) => {
+      if (Date.now() - this._lastTouchMs < touchBufferMs) {
+        return;
+      }
+      this._updateState(isFakeMousedownFromScreenReader(event) ? "keyboard" : "mouse", event);
+    };
+    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}`);
+  }
+}
+const sbbInputModalityDetector = new SbbInputModalityDetector();
+export {
+  sbbInputModalityDetector
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"input-modality-detector.js","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"],"names":[],"mappings":";;;AAmBA,MAAM,QAAQ;AACd,MAAM,UAAU;AAChB,MAAM,MAAM;AACZ,MAAM,OAAO;AACb,MAAM,WAAW;AAkBjB,MAAM,+BAAgE;AAAA,EACpE,YAAY,CAAC,KAAK,SAAS,UAAU,MAAM,KAAK;;AASlD,MAAM,gBAAgB;AAMtB,MAAM,+BAA+B;AAAA,EACnC,SAAS;AAAA,EACT,SAAS;;AAiBX,MAAM,yBAAwB;AAAA;AAAA,EAE5B,IAAW,qBAAkB;AAC3B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,IAAW,mBAAgB;AACzB,WAAO,KAAK;AAAA,EACd;AAAA,EAcA,cAAA;AAtBQ,SAAA,sBAA+C;AAS/C,SAAA,oBAAwC;AAG/B,SAAA,WAA4C;AAAA,MAC3D,GAAG;AAAA,IAAA;AAOG,SAAA,eAAe;AAmBf,SAAA,aAAa,CAAC,UAA8B;AAGlD,UAAI,KAAK,UAAU,YAAY,KAAK,CAAC,YAAY,YAAY,MAAM,OAAO,GAAG;AAC3E;AAAA,MACF;AAEA,WAAK,aAAa,YAAY,KAAK;AAAA,IACrC;AAMQ,SAAA,eAAe,CAAC,UAA2B;AAIjD,UAAI,KAAK,IAAA,IAAQ,KAAK,eAAe,eAAe;AAClD;AAAA,MACF;AAIA,WAAK,aAAa,gCAAgC,KAAK,IAAI,aAAa,SAAS,KAAK;AAAA,IACxF;AAMQ,SAAA,gBAAgB,CAAC,UAA2B;AAGlD,UAAI,iCAAiC,KAAK,GAAG;AAC3C,aAAK,aAAa,YAAY,KAAK;AACnC;AAAA,MACF;AAIA,WAAK,eAAe,KAAK,IAAA;AAEzB,WAAK,aAAa,SAAS,KAAK;AAAA,IAClC;AA5DE,QAAI,CAAC,UAAU;AACb,eAAS,iBAAiB,WAAW,KAAK,YAAY,4BAA4B;AAClF,eAAS,iBAAiB,aAAa,KAAK,cAAc,4BAA4B;AACtF,eAAS,iBAAiB,cAAc,KAAK,eAAe,4BAA4B;AAAA,IAC1F;AAAA,EACF;AAAA,EAEO,QAAK;AACV,SAAK,aAAa,SAAS,IAAI;AAC/B,SAAK,eAAe;AAAA,EACtB;AAAA,EAoDQ,aAAa,UAA4B,OAAmB;AAClE,QAAI,KAAK,qBAAqB;AAC5B,eAAS,gBAAgB,UAAU,OAAO,sBAAsB,KAAK,mBAAmB,EAAE;AAAA,IAC5F;AACA,SAAK,sBAAsB;AAC3B,SAAK,oBAAoB,QAAQ,eAAe,KAAK,IAAI;AACzD,aAAS,gBAAgB,UAAU,IAAI,sBAAsB,KAAK,mBAAmB,EAAE;AAAA,EACzF;AACD;AAEM,MAAM,2BAA2B,IAAI,yBAAA;"}

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"}

package/development/core/a11y/interactivity-checker.js

@@ -0,0 +1,129 @@
+import { isServer } from "lit";
+import { isWebkit, isIOS, isFirefox } from "../dom/platform.js";
+class IsFocusableConfig {
+  constructor() {
+    this.ignoreVisibility = false;
+  }
+}
+class InteractivityChecker {
+  /**
+   * Gets whether an element is disabled.
+   *
+   * @param element Element to be checked.
+   * @returns Whether the element is disabled.
+   */
+  isDisabled(element) {
+    return element.hasAttribute("disabled") || element.matches(":disabled");
+  }
+  /**
+   * 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) {
+    return hasGeometry(element) && getComputedStyle(element).visibility === "visible";
+  }
+  /**
+   * 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) {
+    if (isServer) {
+      return false;
+    }
+    const nodeName = element.nodeName.toLowerCase();
+    const tabIndexValue = getTabIndexValue(element);
+    if (element.hasAttribute("contenteditable")) {
+      return tabIndexValue !== -1;
+    }
+    if (nodeName === "iframe" || nodeName === "object") {
+      return false;
+    }
+    if (isWebkit && isIOS && !isPotentiallyTabbableIOS(element)) {
+      return false;
+    }
+    if (nodeName === "audio") {
+      if (!element.hasAttribute("controls")) {
+        return false;
+      }
+      return tabIndexValue !== -1;
+    }
+    if (nodeName === "video") {
+      if (tabIndexValue === -1) {
+        return false;
+      }
+      if (tabIndexValue !== null) {
+        return true;
+      }
+      return isFirefox || element.hasAttribute("controls");
+    }
+    return element.tabIndex >= 0;
+  }
+  /**
+   * 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, config) {
+    return isPotentiallyFocusable(element) && !element.inert && !this.isDisabled(element) && (config?.ignoreVisibility || this.isVisible(element));
+  }
+}
+const interactivityChecker = new InteractivityChecker();
+function hasGeometry(element) {
+  return !!(element.offsetWidth || element.offsetHeight || typeof element.getClientRects === "function" && element.getClientRects().length);
+}
+function isNativeFormElement(element) {
+  const nodeName = element.nodeName.toLowerCase();
+  return nodeName === "input" || nodeName === "select" || nodeName === "button" || nodeName === "textarea";
+}
+function isHiddenInput(element) {
+  return isInputElement(element) && element.type == "hidden";
+}
+function isAnchorWithHref(element) {
+  return isAnchorElement(element) && element.hasAttribute("href");
+}
+function isInputElement(element) {
+  return element.nodeName.toLowerCase() == "input";
+}
+function isAnchorElement(element) {
+  return element.nodeName.toLowerCase() == "a";
+}
+function hasValidTabIndex(element) {
+  if (!element.hasAttribute("tabindex") || element.tabIndex === void 0) {
+    return false;
+  }
+  const tabIndex = element.getAttribute("tabindex");
+  return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
+}
+function getTabIndexValue(element) {
+  if (!hasValidTabIndex(element)) {
+    return null;
+  }
+  const tabIndex = parseInt(element.getAttribute("tabindex") || "", 10);
+  return isNaN(tabIndex) ? -1 : tabIndex;
+}
+function isPotentiallyTabbableIOS(element) {
+  const nodeName = element.nodeName.toLowerCase();
+  const inputType = nodeName === "input" && element.type;
+  return inputType === "text" || inputType === "password" || nodeName === "select" || nodeName === "textarea";
+}
+function isPotentiallyFocusable(element) {
+  if (isHiddenInput(element)) {
+    return false;
+  }
+  return isNativeFormElement(element) || isAnchorWithHref(element) || element.hasAttribute("contenteditable") || hasValidTabIndex(element);
+}
+export {
+  InteractivityChecker,
+  IsFocusableConfig,
+  interactivityChecker
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"interactivity-checker.js","sources":["../../../../../src/elements/core/a11y/interactivity-checker.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.io/license\n */\n\n// Copied from https://github.com/angular/components/blob/main/src/cdk/a11y/focus-trap/focus-trap.ts\n\n/* eslint-disable @typescript-eslint/no-use-before-define */\nimport { isServer } from 'lit';\n\nimport { isFirefox, isIOS, isWebkit } from '../dom/platform.ts';\n\n/**\n * Configuration for the isFocusable method.\n */\nexport class IsFocusableConfig {\n  /**\n   * Whether to count an element as focusable even if it is not currently visible.\n   */\n  public ignoreVisibility: boolean = false;\n}\n\nexport class InteractivityChecker {\n  /**\n   * Gets whether an element is disabled.\n   *\n   * @param element Element to be checked.\n   * @returns Whether the element is disabled.\n   */\n  public isDisabled(element: HTMLElement): boolean {\n    return element.hasAttribute('disabled') || element.matches(':disabled');\n  }\n\n  /**\n   * Gets whether an element is visible for the purposes of interactivity.\n   *\n   * This will capture states like `display: none` and `visibility: hidden`, but not things like\n   * being clipped by an `overflow: hidden` parent or being outside the viewport.\n   *\n   * @returns Whether the element is visible.\n   */\n  public isVisible(element: HTMLElement): boolean {\n    return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';\n  }\n\n  /**\n   * Gets whether an element can be reached via Tab key.\n   * Assumes that the element has already been checked with isFocusable.\n   *\n   * @param element Element to be checked.\n   * @returns Whether the element is tabbable.\n   */\n  public isTabbable(element: HTMLElement): boolean {\n    // Nothing is tabbable on the server 😎\n    if (isServer) {\n      return false;\n    }\n\n    const nodeName = element.nodeName.toLowerCase();\n    const tabIndexValue = getTabIndexValue(element);\n\n    if (element.hasAttribute('contenteditable')) {\n      return tabIndexValue !== -1;\n    }\n\n    if (nodeName === 'iframe' || nodeName === 'object') {\n      // The frame or object's content may be tabbable depending on the content, but it's\n      // not possibly to reliably detect the content of the frames. We always consider such\n      // elements as non-tabbable.\n      return false;\n    }\n\n    // In iOS, the browser only considers some specific elements as tabbable.\n    if (isWebkit && isIOS && !isPotentiallyTabbableIOS(element)) {\n      return false;\n    }\n\n    if (nodeName === 'audio') {\n      // Audio elements without controls enabled are never tabbable, regardless\n      // of the tabindex attribute explicitly being set.\n      if (!element.hasAttribute('controls')) {\n        return false;\n      }\n      // Audio elements with controls are by default tabbable unless the\n      // tabindex attribute is set to `-1` explicitly.\n      return tabIndexValue !== -1;\n    }\n\n    if (nodeName === 'video') {\n      // For all video elements, if the tabindex attribute is set to `-1`, the video\n      // is not tabbable. Note: We cannot rely on the default `HTMLElement.tabIndex`\n      // property as that one is set to `-1` in Chrome, Edge and Safari v13.1. The\n      // tabindex attribute is the source of truth here.\n      if (tabIndexValue === -1) {\n        return false;\n      }\n      // If the tabindex is explicitly set, and not `-1` (as per check before), the\n      // video element is always tabbable (regardless of whether it has controls or not).\n      if (tabIndexValue !== null) {\n        return true;\n      }\n      // Otherwise (when no explicit tabindex is set), a video is only tabbable if it\n      // has controls enabled. Firefox is special as videos are always tabbable regardless\n      // of whether there are controls or not.\n      return isFirefox || element.hasAttribute('controls');\n    }\n\n    return element.tabIndex >= 0;\n  }\n\n  /**\n   * Gets whether an element can be focused by the user.\n   *\n   * @param element Element to be checked.\n   * @param config The config object with options to customize this method's behavior\n   * @returns Whether the element is focusable.\n   */\n  public isFocusable(element: HTMLElement, config?: IsFocusableConfig): boolean {\n    // Perform checks in order of left to most expensive.\n    // Again, naive approach that does not capture many edge cases and browser quirks.\n    return (\n      isPotentiallyFocusable(element) &&\n      !element.inert &&\n      !this.isDisabled(element) &&\n      (config?.ignoreVisibility || this.isVisible(element))\n    );\n  }\n}\n\n// For unit tests we need to pretend that an element is always visible.\n// This can be done by checking if visibility property is set to empty.\nexport const interactivityChecker = new InteractivityChecker();\n\nfunction hasGeometry(element: HTMLElement): boolean {\n  // Use logic from jQuery to check for an invisible element.\n  // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12\n  return !!(\n    element.offsetWidth ||\n    element.offsetHeight ||\n    (typeof element.getClientRects === 'function' && element.getClientRects().length)\n  );\n}\n\n/** Gets whether an element's  */\nfunction isNativeFormElement(element: Node): boolean {\n  const nodeName = element.nodeName.toLowerCase();\n  return (\n    nodeName === 'input' ||\n    nodeName === 'select' ||\n    nodeName === 'button' ||\n    nodeName === 'textarea'\n  );\n}\n\n/** Gets whether an element is an `<input type=\"hidden\">`. */\nfunction isHiddenInput(element: HTMLElement): boolean {\n  return isInputElement(element) && element.type == 'hidden';\n}\n\n/** Gets whether an element is an anchor that has a href attribute. */\nfunction isAnchorWithHref(element: HTMLElement): boolean {\n  return isAnchorElement(element) && element.hasAttribute('href');\n}\n\n/** Gets whether an element is an input element. */\nfunction isInputElement(element: HTMLElement): element is HTMLInputElement {\n  return element.nodeName.toLowerCase() == 'input';\n}\n\n/** Gets whether an element is an anchor element. */\nfunction isAnchorElement(element: HTMLElement): element is HTMLAnchorElement {\n  return element.nodeName.toLowerCase() == 'a';\n}\n\n/** Gets whether an element has a valid tabindex. */\nfunction hasValidTabIndex(element: HTMLElement): boolean {\n  if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {\n    return false;\n  }\n\n  const tabIndex = element.getAttribute('tabindex');\n  return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));\n}\n\n/**\n * Returns the parsed tabindex from the element attributes instead of returning the\n * evaluated tabindex from the browsers defaults.\n */\nfunction getTabIndexValue(element: HTMLElement): number | null {\n  if (!hasValidTabIndex(element)) {\n    return null;\n  }\n\n  // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054\n  const tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);\n\n  return isNaN(tabIndex) ? -1 : tabIndex;\n}\n\n/** Checks whether the specified element is potentially tabbable on iOS */\nfunction isPotentiallyTabbableIOS(element: HTMLElement): boolean {\n  const nodeName = element.nodeName.toLowerCase();\n  const inputType = nodeName === 'input' && (element as HTMLInputElement).type;\n\n  return (\n    inputType === 'text' ||\n    inputType === 'password' ||\n    nodeName === 'select' ||\n    nodeName === 'textarea'\n  );\n}\n\n/**\n * Gets whether an element is potentially focusable without taking current visible/disabled state\n * into account.\n */\nfunction isPotentiallyFocusable(element: HTMLElement): boolean {\n  // Inputs are potentially focusable *unless* they're type=\"hidden\".\n  if (isHiddenInput(element)) {\n    return false;\n  }\n\n  return (\n    isNativeFormElement(element) ||\n    isAnchorWithHref(element) ||\n    element.hasAttribute('contenteditable') ||\n    hasValidTabIndex(element)\n  );\n}\n"],"names":[],"mappings":"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"}