@sbb-esta/lyne-elements 2.5.1 → 2.7.0

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

@@ -0,0 +1,127 @@
+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) {
+    var _a, _b;
+    this._host = _host;
+    this._abortController = null;
+    (_b = (_a = this._host).addController) == null ? void 0 : _b.call(_a, 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)) {
+        console.warn(`Element matching '[sbb-focus-initial]' is not focusable.`, redirectToElement);
+      }
+      if (!interactivityChecker.isFocusable(redirectToElement)) {
+        const focusableChild = this._getFirstTabbableElement(redirectToElement);
+        focusableChild == null ? void 0 : 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) => {
+      var _a, _b;
+      if (event.key !== "Tab") {
+        return;
+      }
+      if (!event.shiftKey) {
+        const lastFocusableElement = this._getLastTabbableElement(this._host);
+        if (lastFocusableElement && event.composedPath().includes(lastFocusableElement)) {
+          (_a = this._getFirstTabbableElement(this._host)) == null ? void 0 : _a.focus();
+          event.preventDefault();
+        }
+      } else {
+        const firstFocusableElement = this._getFirstTabbableElement(this._host);
+        if (firstFocusableElement && event.composedPath().includes(firstFocusableElement)) {
+          (_b = this._getLastTabbableElement(this._host)) == null ? void 0 : _b.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) {
+    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 = children.length - 1; i >= 0; i--) {
+      const tabbableChild = children[i].nodeType === document.ELEMENT_NODE ? this._getLastTabbableElement(children[i]) : null;
+      if (tabbableChild) {
+        return tabbableChild;
+      }
+    }
+    return null;
+  }
+  _untrap() {
+    var _a;
+    (_a = this._abortController) == null ? void 0 : _a.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.js';\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    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    // 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 null;\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.js

@@ -0,0 +1,25 @@
+import { sbbInputModalityDetector } from "./input-modality-detector.js";
+class SbbFocusVisibleWithinController {
+  constructor(_host) {
+    this._host = _host;
+    this._focusinHandler = () => {
+      this._host.toggleAttribute("data-has-visible-focus-within", sbbInputModalityDetector.mostRecentModality === "keyboard");
+    };
+    this._focusoutHandler = () => {
+      this._host.removeAttribute("data-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

@@ -1,10 +1,21 @@
 export declare const IS_FOCUSABLE_QUERY: string;
+/**
+ * @deprecated will be removed with next major version. Use methods of FocusTrapController.
+ *
+ * Note: the use of this function for more complex scenarios (with many nested elements) may be expensive.
+ */
 export declare function getFocusableElements(elements: HTMLElement[], properties?: {
     filter?: (el: HTMLElement) => boolean;
     findFirstFocusable?: boolean;
     includeInvisibleElements?: boolean;
 }): HTMLElement[];
+/**
+ * @deprecated will be removed with next major version. Use methods of FocusTrapController.
+ */
 export declare function getFirstFocusableElement(elements: HTMLElement[], filter?: (el: HTMLElement) => boolean): HTMLElement | null;
+/**
+ * @deprecated Will be removed with next major release. Use SbbFocusTrapController.
+ */
 export declare class SbbFocusHandler {
     private _controller;
     /**
@@ -17,6 +28,7 @@ export declare class SbbFocusHandler {
         filter?: (el: HTMLElement) => boolean;
         postFilter?: (el: HTMLElement) => boolean;
     }): void;
+    isTrapped(): boolean;
     disconnect(): void;
 }
 //# sourceMappingURL=focus.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"focus.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/focus.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB,QAWnB,CAAC;AAGb,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,WAAW,EAAE,EACvB,UAAU,CAAC,EAAE;IACX,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC;IACtC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,GACA,WAAW,EAAE,CAuCf;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,WAAW,EAAE,EACvB,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,GACpC,WAAW,GAAG,IAAI,CAMpB;AAGD,qBAAa,eAAe;IAC1B,OAAO,CAAC,WAAW,CAAyB;IAE5C;;;;;OAKG;IACI,IAAI,CACT,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC;QACtC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC;KAC3C,GACA,IAAI;IA4CA,UAAU,IAAI,IAAI;CAI1B"}
+{"version":3,"file":"focus.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/focus.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB,QAWnB,CAAC;AAEb;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,WAAW,EAAE,EACvB,UAAU,CAAC,EAAE;IACX,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC;IACtC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,GACA,WAAW,EAAE,CAuCf;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,WAAW,EAAE,EACvB,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,GACpC,WAAW,GAAG,IAAI,CAMpB;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,WAAW,CAAgC;IAEnD;;;;;OAKG;IACI,IAAI,CACT,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC;QACtC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC;KAC3C,GACA,IAAI;IA8CA,SAAS,IAAI,OAAO;IAIpB,UAAU,IAAI,IAAI;CAI1B"}

package/development/core/a11y/focus.js

@@ -0,0 +1,94 @@
+import { interactivityChecker } from "./interactivity-checker.js";
+const IS_FOCUSABLE_QUERY = [
+  "button",
+  "[href]",
+  "input",
+  "select",
+  "textarea",
+  "details",
+  "summary",
+  "[tabindex]"
+].map((selector) => `${selector}:not([disabled],:disabled,[tabindex="-1"],[inert])`).join(",");
+function getFocusableElements(elements, properties) {
+  const focusableEls = /* @__PURE__ */ new Set();
+  function getFocusables(elements2, filter) {
+    var _a;
+    for (const el of elements2) {
+      if (filter && !filter(el)) {
+        continue;
+      }
+      if (el.nodeName === "SLOT") {
+        getFocusables(Array.from(el.assignedElements()), filter);
+        continue;
+      }
+      if (el.matches(IS_FOCUSABLE_QUERY) && ((properties == null ? void 0 : properties.includeInvisibleElements) ?? interactivityChecker.isVisible(el))) {
+        focusableEls.add(el);
+      }
+      if ((properties == null ? void 0 : properties.findFirstFocusable) && focusableEls.size > 0) {
+        break;
+      }
+      if (el.children.length || ((_a = el.shadowRoot) == null ? void 0 : _a.children.length)) {
+        const children = Array.from(el.children).length ? Array.from(el.children) : Array.from(el.shadowRoot.children);
+        getFocusables(children, filter);
+      }
+    }
+  }
+  getFocusables(elements, properties == null ? void 0 : properties.filter);
+  return [...focusableEls];
+}
+function getFirstFocusableElement(elements, filter) {
+  const focusableElements = getFocusableElements(elements, {
+    filter,
+    findFirstFocusable: true
+  });
+  return focusableElements.length ? focusableElements[0] : null;
+}
+class SbbFocusHandler {
+  constructor() {
+    this._controller = null;
+  }
+  /**
+   * @param element in which the focus should be trapped.
+   * @param options options object.
+   * @param options.filter filter function which is applied during searching for focusable element. If an element is filtered, also child elements are filtered.
+   * @param options.postFilter filter function which is applied after collecting focusable elements.
+   */
+  trap(element, options) {
+    this._controller = new AbortController();
+    element.addEventListener("keydown", (event) => {
+      if (event.key !== "Tab") {
+        return;
+      }
+      const elementChildren = Array.from(element.shadowRoot.children || []);
+      const focusableElements = getFocusableElements(elementChildren, {
+        filter: options == null ? void 0 : options.filter
+      });
+      const filteredFocusableElements = focusableElements.filter((options == null ? void 0 : options.postFilter) ?? (() => true));
+      if (!filteredFocusableElements.length) {
+        return;
+      }
+      const firstFocusable = filteredFocusableElements[0];
+      const lastFocusable = filteredFocusableElements[filteredFocusableElements.length - 1];
+      const [pivot, next] = event.shiftKey ? [firstFocusable, lastFocusable] : [lastFocusable, firstFocusable];
+      if (firstFocusable.getRootNode().activeElement === pivot || lastFocusable.getRootNode().activeElement === pivot) {
+        next.focus();
+        event.preventDefault();
+      }
+    }, { signal: this._controller.signal });
+  }
+  isTrapped() {
+    return !!this._controller;
+  }
+  disconnect() {
+    var _a;
+    (_a = this._controller) == null ? void 0 : _a.abort();
+    this._controller = null;
+  }
+}
+export {
+  IS_FOCUSABLE_QUERY,
+  SbbFocusHandler,
+  getFirstFocusableElement,
+  getFocusableElements
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"focus.js","sources":["../../../../../src/elements/core/a11y/focus.ts"],"sourcesContent":["import { interactivityChecker } from './interactivity-checker.js';\n\nexport const IS_FOCUSABLE_QUERY = [\n  'button',\n  '[href]',\n  'input',\n  'select',\n  'textarea',\n  'details',\n  'summary',\n  '[tabindex]',\n]\n  .map((selector) => `${selector}:not([disabled],:disabled,[tabindex=\"-1\"],[inert])`)\n  .join(',');\n\n/**\n * @deprecated will be removed with next major version. Use methods of FocusTrapController.\n *\n * Note: the use of this function for more complex scenarios (with many nested elements) may be expensive.\n */\nexport function getFocusableElements(\n  elements: HTMLElement[],\n  properties?: {\n    filter?: (el: HTMLElement) => boolean;\n    findFirstFocusable?: boolean;\n    includeInvisibleElements?: boolean;\n  },\n): HTMLElement[] {\n  const focusableEls = new Set<HTMLElement>();\n\n  function getFocusables(elements: HTMLElement[], filter?: (el: HTMLElement) => boolean): void {\n    for (const el of elements) {\n      if (filter && !filter(el)) {\n        continue;\n      }\n\n      if (el.nodeName === 'SLOT') {\n        getFocusables(\n          Array.from((el as HTMLSlotElement).assignedElements()) as HTMLElement[],\n          filter,\n        );\n        continue;\n      }\n\n      if (\n        el.matches(IS_FOCUSABLE_QUERY) &&\n        (properties?.includeInvisibleElements ?? interactivityChecker.isVisible(el))\n      ) {\n        focusableEls.add(el);\n      }\n\n      if (properties?.findFirstFocusable && focusableEls.size > 0) {\n        break;\n      }\n\n      if (el.children.length || el.shadowRoot?.children.length) {\n        const children = Array.from(el.children).length\n          ? (Array.from(el.children) as HTMLElement[])\n          : (Array.from(el.shadowRoot!.children) as HTMLElement[]);\n        getFocusables(children, filter);\n      }\n    }\n  }\n  getFocusables(elements, properties?.filter);\n\n  return [...focusableEls];\n}\n\n/**\n * @deprecated will be removed with next major version. Use methods of FocusTrapController.\n */\nexport function getFirstFocusableElement(\n  elements: HTMLElement[],\n  filter?: (el: HTMLElement) => boolean,\n): HTMLElement | null {\n  const focusableElements = getFocusableElements(elements, {\n    filter,\n    findFirstFocusable: true,\n  });\n  return focusableElements.length ? focusableElements[0] : null;\n}\n\n/**\n * @deprecated Will be removed with next major release. Use SbbFocusTrapController.\n */\nexport class SbbFocusHandler {\n  private _controller: AbortController | null = null;\n\n  /**\n   * @param element in which the focus should be trapped.\n   * @param options options object.\n   * @param options.filter filter function which is applied during searching for focusable element. If an element is filtered, also child elements are filtered.\n   * @param options.postFilter filter function which is applied after collecting focusable elements.\n   */\n  public trap(\n    element: HTMLElement,\n    options?: {\n      filter?: (el: HTMLElement) => boolean;\n      postFilter?: (el: HTMLElement) => boolean;\n    },\n  ): void {\n    this._controller = new AbortController();\n\n    element.addEventListener(\n      'keydown',\n      (event) => {\n        if (event.key !== 'Tab') {\n          return;\n        }\n\n        // Dynamically get first and last focusable element, as this might have changed since opening overlay\n        const elementChildren: HTMLElement[] = Array.from(\n          element.shadowRoot!.children || [],\n        ) as HTMLElement[];\n        const focusableElements = getFocusableElements(elementChildren, {\n          filter: options?.filter,\n        });\n        const filteredFocusableElements = focusableElements.filter(\n          options?.postFilter ?? (() => true),\n        );\n\n        if (!filteredFocusableElements.length) {\n          return;\n        }\n\n        const firstFocusable = filteredFocusableElements[0] as HTMLElement;\n        const lastFocusable = filteredFocusableElements[\n          filteredFocusableElements.length - 1\n        ] as HTMLElement;\n\n        const [pivot, next] = event.shiftKey\n          ? [firstFocusable, lastFocusable]\n          : [lastFocusable, firstFocusable];\n\n        if (\n          (firstFocusable.getRootNode() as Document | ShadowRoot).activeElement === pivot ||\n          (lastFocusable.getRootNode() as Document | ShadowRoot).activeElement === pivot\n        ) {\n          next.focus();\n          event.preventDefault();\n        }\n      },\n      { signal: this._controller.signal },\n    );\n  }\n\n  public isTrapped(): boolean {\n    return !!this._controller;\n  }\n\n  public disconnect(): void {\n    this._controller?.abort();\n    this._controller = null;\n  }\n}\n"],"names":["elements"],"mappings":";AAEO,MAAM,qBAAqB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD,EACE,IAAI,CAAC,aAAa,GAAG,QAAQ,oDAAoD,EACjF,KAAK,GAAG;AAOK,SAAA,qBACd,UACA,YAIC;AAEK,QAAA,mCAAmB;AAEhB,WAAA,cAAcA,WAAyB,QAAqC;;AACnF,eAAW,MAAMA,WAAU;AACzB,UAAI,UAAU,CAAC,OAAO,EAAE,GAAG;AACzB;AAAA,MAAA;AAGE,UAAA,GAAG,aAAa,QAAQ;AAC1B,sBACE,MAAM,KAAM,GAAuB,iBAAkB,CAAA,GACrD,MAAM;AAER;AAAA,MAAA;AAIA,UAAA,GAAG,QAAQ,kBAAkB,OAC5B,yCAAY,6BAA4B,qBAAqB,UAAU,EAAE,IAC1E;AACA,qBAAa,IAAI,EAAE;AAAA,MAAA;AAGrB,WAAI,yCAAY,uBAAsB,aAAa,OAAO,GAAG;AAC3D;AAAA,MAAA;AAGF,UAAI,GAAG,SAAS,YAAU,QAAG,eAAH,mBAAe,SAAS,SAAQ;AACxD,cAAM,WAAW,MAAM,KAAK,GAAG,QAAQ,EAAE,SACpC,MAAM,KAAK,GAAG,QAAQ,IACtB,MAAM,KAAK,GAAG,WAAY,QAAQ;AACvC,sBAAc,UAAU,MAAM;AAAA,MAAA;AAAA,IAChC;AAAA,EACF;AAEY,gBAAA,UAAU,yCAAY,MAAM;AAEnC,SAAA,CAAC,GAAG,YAAY;AACzB;AAKgB,SAAA,yBACd,UACA,QAAqC;AAE/B,QAAA,oBAAoB,qBAAqB,UAAU;AAAA,IACvD;AAAA,IACA,oBAAoB;AAAA,EAAA,CACrB;AACD,SAAO,kBAAkB,SAAS,kBAAkB,CAAC,IAAI;AAC3D;MAKa,gBAAe;AAAA,EAA5B,cAAA;AACU,SAAW,cAA2B;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQvC,KACL,SACA,SAGC;AAEI,SAAA,cAAc,IAAI;AAEf,YAAA,iBACN,WACA,CAAC,UAAS;AACJ,UAAA,MAAM,QAAQ,OAAO;AACvB;AAAA,MAAA;AAIF,YAAM,kBAAiC,MAAM,KAC3C,QAAQ,WAAY,YAAY,EAAE;AAE9B,YAAA,oBAAoB,qBAAqB,iBAAiB;AAAA,QAC9D,QAAQ,mCAAS;AAAA,MAAA,CAClB;AACD,YAAM,4BAA4B,kBAAkB,QAClD,mCAAS,gBAAe,MAAM,KAAK;AAGjC,UAAA,CAAC,0BAA0B,QAAQ;AACrC;AAAA,MAAA;AAGI,YAAA,iBAAiB,0BAA0B,CAAC;AAClD,YAAM,gBAAgB,0BACpB,0BAA0B,SAAS,CAAC;AAGtC,YAAM,CAAC,OAAO,IAAI,IAAI,MAAM,WACxB,CAAC,gBAAgB,aAAa,IAC9B,CAAC,eAAe,cAAc;AAG/B,UAAA,eAAe,YAAwC,EAAA,kBAAkB,SACzE,cAAc,YAAA,EAAwC,kBAAkB,OACzE;AACA,aAAK,MAAK;AACV,cAAM,eAAc;AAAA,MAAA;AAAA,OAGxB,EAAE,QAAQ,KAAK,YAAY,QAAQ;AAAA,EAAA;AAAA,EAIhC,YAAS;AACP,WAAA,CAAC,CAAC,KAAK;AAAA,EAAA;AAAA,EAGT,aAAU;;AACf,eAAK,gBAAL,mBAAkB;AAClB,SAAK,cAAc;AAAA,EAAA;AAEtB;"}

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

@@ -51,8 +51,13 @@ declare class SbbInputModalityDetector {
      * gets bound.
      */
     private _onTouchstart;
+    private _updateState;
 }
 export declare const sbbInputModalityDetector: SbbInputModalityDetector;
+/**
+ * @deprecated Will be removed with next major version.
+ * Set the input modality in order to avoid showing the outline in Safari.
+ */
 export declare function setModalityOnNextFocus(elementToFocus: HTMLElement | null | undefined): void;
 export {};
 //# sourceMappingURL=input-modality-detector.d.ts.map

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

@@ -1 +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;IAMpB;;;OAGG;IACH,OAAO,CAAC,UAAU,CAShB;IAEF;;;OAGG;IACH,OAAO,CAAC,YAAY,CAYlB;IAEF;;;OAGG;IACH,OAAO,CAAC,aAAa,CAenB;CACH;AAED,eAAO,MAAM,wBAAwB,0BAAiC,CAAC;AAGvE,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAyB3F"}
+{"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;AAEvE;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAyB3F"}

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

@@ -0,0 +1,96 @@
+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) => {
+      var _a, _b;
+      if ((_b = (_a = this._options) == null ? void 0 : _a.ignoreKeys) == null ? void 0 : _b.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();
+function setModalityOnNextFocus(elementToFocus) {
+  if (!elementToFocus) {
+    return;
+  }
+  const mostRecentModality = sbbInputModalityDetector.mostRecentModality;
+  if (!(elementToFocus && mostRecentModality !== null)) {
+    return;
+  }
+  elementToFocus.addEventListener("focus", () => {
+    elementToFocus.setAttribute("data-focus-origin", mostRecentModality);
+    elementToFocus.addEventListener("blur", () => elementToFocus.removeAttribute("data-focus-origin"), {
+      once: true
+    });
+  }, { once: true });
+}
+export {
+  sbbInputModalityDetector,
+  setModalityOnNextFocus
+};
+//# 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.js';\n\nimport {\n  isFakeMousedownFromScreenReader,\n  isFakeTouchstartFromScreenReader,\n} from './fake-event-detection.js';\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\n/**\n * @deprecated Will be removed with next major version.\n * Set the input modality in order to avoid showing the outline in Safari.\n */\nexport function setModalityOnNextFocus(elementToFocus: HTMLElement | null | undefined): void {\n  if (!elementToFocus) {\n    return;\n  }\n\n  const mostRecentModality = sbbInputModalityDetector.mostRecentModality;\n\n  // Set focus origin to element which should receive focus\n  if (!(elementToFocus && mostRecentModality !== null)) {\n    return;\n  }\n  elementToFocus.addEventListener(\n    'focus',\n    () => {\n      elementToFocus.setAttribute('data-focus-origin', mostRecentModality);\n      elementToFocus.addEventListener(\n        'blur',\n        () => elementToFocus.removeAttribute('data-focus-origin'),\n        {\n          once: true,\n        },\n      );\n    },\n    { once: true },\n  );\n}\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,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAad,IAAW,mBAAgB;AACzB,WAAO,KAAK;AAAA,EAAA;AAAA,EAed,cAAA;AAtBQ,SAAmB,sBAA4B;AAS/C,SAAiB,oBAAuB;AAG/B,SAAA,WAA4C;AAAA,MAC3D,GAAG;AAAA;AAOG,SAAY,eAAG;AAmBf,SAAA,aAAa,CAAC,UAA8B;;AAG9C,WAAA,gBAAK,aAAL,mBAAe,eAAf,mBAA2B,KAAK,CAAC,YAAY,YAAY,MAAM,UAAU;AAC3E;AAAA,MAAA;AAGG,WAAA,aAAa,YAAY,KAAK;AAAA,IACrC;AAMQ,SAAA,eAAe,CAAC,UAA2B;AAIjD,UAAI,KAAK,IAAA,IAAQ,KAAK,eAAe,eAAe;AAClD;AAAA,MAAA;AAKF,WAAK,aAAa,gCAAgC,KAAK,IAAI,aAAa,SAAS,KAAK;AAAA,IACxF;AAMQ,SAAA,gBAAgB,CAAC,UAA2B;AAG9C,UAAA,iCAAiC,KAAK,GAAG;AACtC,aAAA,aAAa,YAAY,KAAK;AACnC;AAAA,MAAA;AAKG,WAAA,eAAe,KAAK;AAEpB,WAAA,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,IAAA;AAAA,EAC1F;AAAA,EAGK,QAAK;AACL,SAAA,aAAa,SAAS,IAAI;AAC/B,SAAK,eAAe;AAAA,EAAA;AAAA,EAqDd,aAAa,UAA4B,OAAmB;AAClE,QAAI,KAAK,qBAAqB;AAC5B,eAAS,gBAAgB,UAAU,OAAO,sBAAsB,KAAK,mBAAmB,EAAE;AAAA,IAAA;AAE5F,SAAK,sBAAsB;AAC3B,SAAK,oBAAoB,QAAQ,eAAe,KAAK,IAAI;AACzD,aAAS,gBAAgB,UAAU,IAAI,sBAAsB,KAAK,mBAAmB,EAAE;AAAA,EAAA;AAE1F;AAEY,MAAA,2BAA2B,IAAI;AAMtC,SAAU,uBAAuB,gBAA8C;AACnF,MAAI,CAAC,gBAAgB;AACnB;AAAA,EAAA;AAGF,QAAM,qBAAqB,yBAAyB;AAGhD,MAAA,EAAE,kBAAkB,uBAAuB,OAAO;AACpD;AAAA,EAAA;AAEa,iBAAA,iBACb,SACA,MAAK;AACY,mBAAA,aAAa,qBAAqB,kBAAkB;AACnE,mBAAe,iBACb,QACA,MAAM,eAAe,gBAAgB,mBAAmB,GACxD;AAAA,MACE,MAAM;AAAA,IAAA,CACP;AAAA,EAAA,GAGL,EAAE,MAAM,MAAM;AAElB;"}

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

@@ -1,8 +1,33 @@
-export declare function hasGeometry(element: HTMLElement): boolean;
+/**
+ * @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
+ */
+/**
+ * @deprecated Will be removed with next major version.
+ */
 export interface InterfaceInteractivityChecker {
     isVisible(element: HTMLElement): boolean;
 }
-export declare class InteractivityChecker implements InterfaceInteractivityChecker {
+/**
+ * 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.
      *
@@ -12,6 +37,27 @@ export declare class InteractivityChecker implements InterfaceInteractivityCheck
      * @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: InterfaceInteractivityChecker;
+export declare const interactivityChecker: InteractivityChecker;
+/**
+ * @deprecated Will no longer be available with next major version.
+ * TODO: remove export keyword
+ */
+export declare function hasGeometry(element: HTMLElement): boolean;
 //# sourceMappingURL=interactivity-checker.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"interactivity-checker.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/interactivity-checker.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAQzD;AAED,MAAM,WAAW,6BAA6B;IAC5C,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC;CAC1C;AAED,qBAAa,oBAAqB,YAAW,6BAA6B;IACxE;;;;;;;OAOG;IACI,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO;CAGhD;AAUD,eAAO,MAAM,oBAAoB,EAAE,6BAIH,CAAC"}
+{"version":3,"file":"interactivity-checker.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/interactivity-checker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC;CAC1C;AAED;;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;AAE/D;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAQzD"}