@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/core/a11y.js

@@ -0,0 +1,295 @@
+import { getDocumentWritingMode } from "./dom.js";
+import { isServer } from "lit";
+import { getEventTarget } from "./eventing.js";
+function getPrevAndNextKeys() {
+  if (getDocumentWritingMode() === "rtl") {
+    return { prevKey: "ArrowRight", nextKey: "ArrowLeft" };
+  } else {
+    return { prevKey: "ArrowLeft", nextKey: "ArrowRight" };
+  }
+}
+function isArrowKeyPressed(event) {
+  return ["ArrowRight", "ArrowLeft", "ArrowUp", "ArrowDown"].includes(event.key);
+}
+function isPreviousArrowKeyPressed(event) {
+  return event.key === "ArrowUp" || event.key === getPrevAndNextKeys().prevKey;
+}
+function isNextArrowKeyPressed(event) {
+  return event.key === "ArrowDown" || event.key === getPrevAndNextKeys().nextKey;
+}
+function isArrowKeyOrPageKeysPressed(event) {
+  return isArrowKeyPressed(event) || ["PageUp", "PageDown", "Home", "End"].includes(event.key);
+}
+function calcNextIndexInRange(currentIndex, maxIndex, offset) {
+  return (currentIndex + offset + maxIndex) % maxIndex;
+}
+function getLastIndex(size) {
+  return size - 1;
+}
+const firstIndex = 0;
+function getNextElementIndex(event, current, size) {
+  const { prevKey, nextKey } = getPrevAndNextKeys();
+  if (event.key === prevKey || event.key === "ArrowUp") {
+    return current < firstIndex ? getLastIndex(size) : calcNextIndexInRange(current, size, -1);
+  } else if (event.key === nextKey || event.key === "ArrowDown") {
+    return current >= size ? firstIndex : calcNextIndexInRange(current, size, 1);
+  }
+  return current;
+}
+function isFakeMousedownFromScreenReader(event) {
+  return event.buttons === 0 || event.detail === 0;
+}
+function isFakeTouchstartFromScreenReader(event) {
+  const touch = event.touches && event.touches[0] || event.changedTouches && event.changedTouches[0];
+  return !!touch && touch.identifier === -1 && (touch.radiusX == null || touch.radiusX === 1) && (touch.radiusY == null || touch.radiusY === 1);
+}
+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 {
+  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._mostRecentModality = "keyboard";
+      this._mostRecentTarget = getEventTarget(event);
+    };
+    this._onMousedown = (event) => {
+      if (Date.now() - this._lastTouchMs < touchBufferMs) {
+        return;
+      }
+      this._mostRecentModality = isFakeMousedownFromScreenReader(event) ? "keyboard" : "mouse";
+      this._mostRecentTarget = getEventTarget(event);
+    };
+    this._onTouchstart = (event) => {
+      if (isFakeTouchstartFromScreenReader(event)) {
+        this._mostRecentModality = "keyboard";
+        this._mostRecentTarget = getEventTarget(event);
+        return;
+      }
+      this._lastTouchMs = Date.now();
+      this._mostRecentModality = "touch";
+      this._mostRecentTarget = getEventTarget(event);
+    };
+    if (!isServer) {
+      document.addEventListener("keydown", this._onKeydown, modalityEventListenerOptions);
+      document.addEventListener("mousedown", this._onMousedown, modalityEventListenerOptions);
+      document.addEventListener("touchstart", this._onTouchstart, modalityEventListenerOptions);
+    }
+  }
+  /** The most recently detected input modality. */
+  get mostRecentModality() {
+    return this._mostRecentModality;
+  }
+  reset() {
+    this._mostRecentModality = "mouse";
+    this._mostRecentTarget = null;
+    this._lastTouchMs = 0;
+  }
+  /**
+   * 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;
+  }
+}
+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 }
+  );
+}
+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);
+  }
+}
+function hasGeometry(element) {
+  return !!(element.offsetWidth || element.offsetHeight || typeof element.getClientRects === "function" && element.getClientRects().length);
+}
+class InteractivityChecker {
+  /**
+   * 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";
+  }
+}
+class InteractivityCheckerMock {
+  isVisible() {
+    return true;
+  }
+}
+const interactivityChecker = typeof getComputedStyle === "undefined" || getComputedStyle(document.documentElement).visibility === "" ? new InteractivityCheckerMock() : new InteractivityChecker();
+const IS_FOCUSABLE_QUERY = [
+  "button",
+  "[href]",
+  "input",
+  "select",
+  "textarea",
+  "details",
+  "summary:not(:disabled)",
+  "[tabindex]"
+].map((selector) => `${selector}:not([disabled],[tabindex="-1"])`).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 = new AbortController();
+  }
+  /**
+   * @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) {
+    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 }
+    );
+  }
+  disconnect() {
+    this._controller.abort();
+    this._controller = new AbortController();
+  }
+}
+export {
+  IS_FOCUSABLE_QUERY,
+  InteractivityChecker,
+  SbbFocusHandler,
+  SbbFocusVisibleWithinController,
+  getFirstFocusableElement,
+  getFocusableElements,
+  getNextElementIndex,
+  hasGeometry,
+  interactivityChecker,
+  isArrowKeyOrPageKeysPressed,
+  isArrowKeyPressed,
+  isFakeMousedownFromScreenReader,
+  isFakeTouchstartFromScreenReader,
+  isNextArrowKeyPressed,
+  isPreviousArrowKeyPressed,
+  sbbInputModalityDetector,
+  setModalityOnNextFocus
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"a11y.js","sources":["../../../../src/elements/core/a11y/arrow-navigation.ts","../../../../src/elements/core/a11y/fake-event-detection.ts","../../../../src/elements/core/a11y/input-modality-detector.ts","../../../../src/elements/core/a11y/focus-visible-within-controller.ts","../../../../src/elements/core/a11y/interactivity-checker.ts","../../../../src/elements/core/a11y/focus.ts"],"sourcesContent":["import { getDocumentWritingMode } from '../dom.js';\n\ninterface PrevAndNextKeys {\n  prevKey: string;\n  nextKey: string;\n}\n\nfunction getPrevAndNextKeys(): PrevAndNextKeys {\n  if (getDocumentWritingMode() === 'rtl') {\n    return { prevKey: 'ArrowRight', nextKey: 'ArrowLeft' };\n  } else {\n    return { prevKey: 'ArrowLeft', nextKey: 'ArrowRight' };\n  }\n}\n\n/**\n * Check if the key pressed is among those allowed for navigation.\n * @param event The keyboard event to check.\n */\nexport function isArrowKeyPressed(event: KeyboardEvent): boolean {\n  return ['ArrowRight', 'ArrowLeft', 'ArrowUp', 'ArrowDown'].includes(event.key);\n}\n\n/**\n * Check if the key pressed should move the navigation to the next element.\n * @param event The keyboard event to check.\n */\nexport function isPreviousArrowKeyPressed(event: KeyboardEvent): boolean {\n  return event.key === 'ArrowUp' || event.key === getPrevAndNextKeys().prevKey;\n}\n\n/**\n * Check if the key pressed should move the navigation to the next element.\n * @param event The keyboard event to check.\n */\nexport function isNextArrowKeyPressed(event: KeyboardEvent): boolean {\n  return event.key === 'ArrowDown' || event.key === getPrevAndNextKeys().nextKey;\n}\n\n/**\n * Check if the key pressed is among those allowed for navigation.\n * @param event The keyboard event to check.\n */\nexport function isArrowKeyOrPageKeysPressed(event: KeyboardEvent): boolean {\n  return isArrowKeyPressed(event) || ['PageUp', 'PageDown', 'Home', 'End'].includes(event.key);\n}\n\n/**\n * Calculate the index of the next element based on the given offset.\n * @param currentIndex The index of the current element.\n * @param maxIndex The maximum permitted value (e.g. array size).\n * @param offset The amount to move by.\n */\nfunction calcNextIndexInRange(currentIndex: number, maxIndex: number, offset: number): number {\n  return (currentIndex + offset + maxIndex) % maxIndex;\n}\n\nfunction getLastIndex(size: number): number {\n  return size - 1;\n}\n\nconst firstIndex = 0;\n\n/**\n * Gets the index of the element to move to, based on the keyboard input, the current element in the list and the list size.\n * @param event The keyboard event to check.\n * @param current The index of the current element in the list.\n * @param size The size of the list.\n * @returns if it is a 'previous' event, returns the index of the previous element,\n * or the index of the last one if the current element is the first in the list;\n * if it is a 'next' event, returns the index of the next element,\n * or the index of the first one, if the current is the last in the list.\n */\nexport function getNextElementIndex(event: KeyboardEvent, current: number, size: number): number {\n  const { prevKey, nextKey } = getPrevAndNextKeys();\n\n  if (event.key === prevKey || event.key === 'ArrowUp') {\n    return current < firstIndex ? getLastIndex(size) : calcNextIndexInRange(current, size, -1);\n  } else if (event.key === nextKey || event.key === 'ArrowDown') {\n    return current >= size ? firstIndex : calcNextIndexInRange(current, size, 1);\n  }\n  return current;\n}\n","// This implementation is taken from https://github.com/angular/components/blob/main/src/cdk/a11y/fake-event-detection.ts\n\n/** Gets whether an event could be a faked `mousedown` event dispatched by a screen reader. */\nexport function isFakeMousedownFromScreenReader(event: MouseEvent): boolean {\n  // Some screen readers will dispatch a fake `mousedown` event when pressing enter or space on\n  // a clickable element. We can distinguish these events when `event.buttons` is zero, or\n  // `event.detail` is zero depending on the browser:\n  // - `event.buttons` works on Firefox, but fails on Chrome.\n  // - `detail` works on Chrome, but fails on Firefox.\n  return event.buttons === 0 || event.detail === 0;\n}\n\n/** Gets whether an event could be a faked `touchstart` event dispatched by a screen reader. */\nexport function isFakeTouchstartFromScreenReader(event: TouchEvent): boolean {\n  const touch: Touch | undefined =\n    (event.touches && event.touches[0]) || (event.changedTouches && event.changedTouches[0]);\n\n  // A fake `touchstart` can be distinguished from a real one by looking at the `identifier`\n  // which is typically >= 0 on a real device versus -1 from a screen reader. Just to be safe,\n  // we can also look at `radiusX` and `radiusY`. This behavior was observed against a Windows 10\n  // device with a touch screen running NVDA v2020.4 and Firefox 85 or Chrome 88.\n  return (\n    !!touch &&\n    touch.identifier === -1 &&\n    (touch.radiusX == null || touch.radiusX === 1) &&\n    (touch.radiusY == null || touch.radiusY === 1)\n  );\n}\n","// 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  public reset(): void {\n    this._mostRecentModality = 'mouse';\n    this._mostRecentTarget = null;\n    this._lastTouchMs = 0;\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  /**\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._mostRecentModality = 'keyboard';\n    this._mostRecentTarget = getEventTarget(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._mostRecentModality = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';\n    this._mostRecentTarget = getEventTarget(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._mostRecentModality = 'keyboard';\n      this._mostRecentTarget = getEventTarget(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._mostRecentModality = 'touch';\n    this._mostRecentTarget = getEventTarget(event);\n  };\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\nexport const sbbInputModalityDetector = new SbbInputModalityDetector();\n\n// Set the input modality in order to avoid showing the outline in Safari.\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","import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nimport { sbbInputModalityDetector } from './input-modality-detector.js';\n\n// Determine whether the element has a visible focus within.\nexport class SbbFocusVisibleWithinController implements ReactiveController {\n  private _focusinHandler = (): void => {\n    this._host.toggleAttribute(\n      'data-has-visible-focus-within',\n      sbbInputModalityDetector.mostRecentModality === 'keyboard',\n    );\n  };\n\n  private _focusoutHandler = (): void => {\n    this._host.removeAttribute('data-has-visible-focus-within');\n  };\n\n  public constructor(private _host: ReactiveControllerHost & HTMLElement) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    this._host.addEventListener('focusin', this._focusinHandler);\n    this._host.addEventListener('focusout', this._focusoutHandler);\n  }\n\n  public hostDisconnected(): void {\n    this._host.removeEventListener('focusin', this._focusinHandler);\n    this._host.removeEventListener('focusout', this._focusoutHandler);\n  }\n}\n","export function 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\nexport interface InterfaceInteractivityChecker {\n  isVisible(element: HTMLElement): boolean;\n}\n\nexport class InteractivityChecker implements InterfaceInteractivityChecker {\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\nclass InteractivityCheckerMock implements InterfaceInteractivityChecker {\n  public isVisible(): boolean {\n    return true;\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: InterfaceInteractivityChecker =\n  typeof getComputedStyle === 'undefined' ||\n  getComputedStyle(document.documentElement).visibility === ''\n    ? new InteractivityCheckerMock()\n    : new InteractivityChecker();\n","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:not(:disabled)',\n  '[tabindex]',\n]\n  .map((selector) => `${selector}:not([disabled],[tabindex=\"-1\"])`)\n  .join(',');\n\n// Note: the use of this function for more complex scenarios (with many nested elements) may be expensive.\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\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\nexport class SbbFocusHandler {\n  private _controller = new AbortController();\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    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 disconnect(): void {\n    this._controller.abort();\n    this._controller = new AbortController();\n  }\n}\n"],"names":["elements"],"mappings":"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"}

package/development/core/base-elements/action-base-element.d.ts

@@ -0,0 +1,11 @@
+import { LitElement, TemplateResult } from 'lit';
+
+export declare abstract class SbbActionBaseElement extends LitElement {
+    protected get maybeDisabled(): boolean | undefined;
+    protected setupBaseEventHandlers(): void;
+    /** Override this method to render the component template. */
+    protected renderTemplate(): TemplateResult;
+    /** Default render method for button-like components. */
+    protected render(): TemplateResult;
+}
+//# sourceMappingURL=action-base-element.d.ts.map

package/development/core/base-elements/action-base-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-base-element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/action-base-element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAe5D,8BAIsB,oBAAqB,SAAQ,UAAU;IAC3D,SAAS,KAAK,aAAa,IAAI,OAAO,GAAG,SAAS,CAGjD;IAED,SAAS,CAAC,sBAAsB,IAAI,IAAI;IAexC,6DAA6D;IAC7D,SAAS,CAAC,cAAc,IAAI,cAAc;IAI1C,wDAAwD;cACrC,MAAM,IAAI,cAAc;CAO5C"}

package/development/core/base-elements/button-base-element.d.ts

@@ -0,0 +1,46 @@
+import { SbbActionBaseElement } from './action-base-element.js';
+
+/** Enumeration for type attribute in <button> HTML tag. */
+export type SbbButtonType = 'button' | 'reset' | 'submit';
+/** Button base class. */
+export declare abstract class SbbButtonBaseElement extends SbbActionBaseElement {
+    /** The type attribute to use for the button. */
+    type: SbbButtonType;
+    /**
+     * The name of the button element.
+     *
+     * @description Developer note: In this case updating the attribute must be synchronous.
+     * Due to this it is implemented as a getter/setter and the attributeChangedCallback() handles the diff check.
+     */
+    set name(name: string);
+    get name(): string;
+    /**
+     * The value of the button element.
+     *
+     * @description Developer note: In this case updating the attribute must be synchronous.
+     * Due to this it is implemented as a getter/setter and the attributeChangedCallback() handles the diff check.
+     */
+    set value(value: string);
+    get value(): string;
+    /** The <form> element to associate the button with. */
+    form?: string;
+    private _handleButtonClick;
+    /**
+     * Prevents scrolling from pressing Space, when the event target is an action element.
+     * Also sets data-active attribute.
+     * @param event The origin event.
+     */
+    private _preventScrollOnSpaceKeydown;
+    private _removeActiveMarker;
+    /**
+     * Dispatches a 'click' PointerEvent if the original keyboard event is a 'Space' press.
+     * As verified with the native button, when 'Space' is pressed, a 'click' event is dispatched
+     * after the 'keyup' event.
+     * @param event The origin event.
+     */
+    private _dispatchClickEventOnSpaceKeyup;
+    private _dispatchClickEvent;
+    constructor();
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+}
+//# sourceMappingURL=button-base-element.d.ts.map

package/development/core/base-elements/button-base-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"button-base-element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/button-base-element.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEhE,2DAA2D;AAC3D,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE1D,yBAAyB;AACzB,8BAKsB,oBAAqB,SAAQ,oBAAoB;IACrE,gDAAgD;IAC7B,IAAI,EAAE,aAAa,CAAY;IAElD;;;;;OAKG;IACH,IACW,IAAI,CAAC,IAAI,EAAE,MAAM,EAE3B;IACD,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;;OAKG;IACH,IACW,KAAK,CAAC,KAAK,EAAE,MAAM,EAE7B;IACD,IAAW,KAAK,IAAI,MAAM,CAEzB;IAED,uDAAuD;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEjC,OAAO,CAAC,kBAAkB,CAmBxB;IAEF;;;;OAIG;IACH,OAAO,CAAC,4BAA4B,CAKlC;IAEF,OAAO,CAAC,mBAAmB,CAEzB;IAEF;;;;;OAKG;IACH,OAAO,CAAC,+BAA+B,CAKrC;IAEF,OAAO,CAAC,mBAAmB,CAezB;;IAwBc,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,IAAI;CAKR"}

package/development/core/base-elements/link-base-element.d.ts

@@ -0,0 +1,31 @@
+import { TemplateResult } from 'lit';
+import { SbbLanguageController } from '../controllers.js';
+import { SbbActionBaseElement } from './action-base-element.js';
+
+/** Enumeration for 'target' attribute in <a> HTML tag. */
+export type LinkTargetType = '_blank' | '_self' | '_parent' | '_top';
+/** Link base class. */
+export declare abstract class SbbLinkBaseElement extends SbbActionBaseElement {
+    /** The href value you want to link to. */
+    href?: string;
+    /** Where to display the linked URL. */
+    target?: LinkTargetType | string;
+    /** The relationship of the linked URL as space-separated link types. */
+    rel?: string;
+    /** Whether the browser will show the download dialog on click. */
+    download?: boolean;
+    /** This will be forwarded as aria-label to the inner anchor element. */
+    accessibilityLabel: string | undefined;
+    protected language: SbbLanguageController;
+    constructor();
+    /** @internal */
+    focus(options?: FocusOptions | undefined): void;
+    /** @internal */
+    blur(): void;
+    /** @internal */
+    click(): void;
+    private _evaluateRelAttribute;
+    /** Default render method for link-like components. Can be overridden if the LinkRenderVariables are not needed. */
+    protected render(): TemplateResult;
+}
+//# sourceMappingURL=link-base-element.d.ts.map

package/development/core/base-elements/link-base-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-base-element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/link-base-element.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAK1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEhE,OAAO,6BAA6B,CAAC;AAErC,0DAA0D;AAC1D,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAErE,uBAAuB;AACvB,8BAGsB,kBAAmB,SAAQ,oBAAoB;IACnE,0CAA0C;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEjC,uCAAuC;IACpB,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IAEpD,wEAAwE;IACrD,GAAG,CAAC,EAAE,MAAM,CAAC;IAEhC,kEAAkE;IAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEvD,wEAAwE;IACjB,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IAE9F,SAAS,CAAC,QAAQ,wBAAmC;;IASrD,gBAAgB;IACA,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI;IAI/D,gBAAgB;IACA,IAAI,IAAI,IAAI;IAI5B,gBAAgB;IACA,KAAK,IAAI,IAAI;IAI7B,OAAO,CAAC,qBAAqB,CAE3B;IAEF,mHAAmH;cAChG,MAAM,IAAI,cAAc;CAqB5C"}

package/development/core/base-elements/open-close-base-element.d.ts

@@ -0,0 +1,37 @@
+import { LitElement } from 'lit';
+import { EventEmitter } from '../eventing.js';
+import { SbbOpenedClosedState } from '../interfaces.js';
+
+/**
+ * Base class for overlay components.
+ *
+ * @event willOpen - Emits whenever the component starts the opening transition. Can be canceled.
+ * @event didOpen - Emits whenever the component is opened.
+ * @event willClose - Emits whenever the component begins the closing transition. Can be canceled.
+ * @event didClose - Emits whenever the component is closed.
+ */
+export declare abstract class SbbOpenCloseBaseElement extends LitElement {
+    static readonly events: {
+        readonly willOpen: "willOpen";
+        readonly didOpen: "didOpen";
+        readonly willClose: "willClose";
+        readonly didClose: "didClose";
+    };
+    /** The state of the component. */
+    protected set state(state: SbbOpenedClosedState);
+    protected get state(): SbbOpenedClosedState;
+    /** Emits whenever the component starts the opening transition. */
+    protected willOpen: EventEmitter;
+    /** Emits whenever the component is opened. */
+    protected didOpen: EventEmitter;
+    /** Emits whenever the component begins the closing transition. */
+    protected willClose: EventEmitter;
+    /** Emits whenever the component is closed. */
+    protected didClose: EventEmitter;
+    /** Opens the component. */
+    abstract open(): void;
+    /** Closes the component. */
+    abstract close(): void;
+    connectedCallback(): void;
+}
+//# sourceMappingURL=open-close-base-element.d.ts.map

package/development/core/base-elements/open-close-base-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-close-base-element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/open-close-base-element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D;;;;;;;GAOG;AACH,8BAAsB,uBAAwB,SAAQ,UAAU;IAC9D,gBAAuB,MAAM;;;;;MAKlB;IAEX,kCAAkC;IAClC,SAAS,KAAK,KAAK,CAAC,KAAK,EAAE,oBAAoB,EAE9C;IACD,SAAS,KAAK,KAAK,IAAI,oBAAoB,CAE1C;IAED,kEAAkE;IAClE,SAAS,CAAC,QAAQ,EAAE,YAAY,CAG9B;IAEF,8CAA8C;IAC9C,SAAS,CAAC,OAAO,EAAE,YAAY,CAAkE;IAEjG,kEAAkE;IAClE,SAAS,CAAC,SAAS,EAAE,YAAY,CAG/B;IAEF,8CAA8C;IAC9C,SAAS,CAAC,QAAQ,EAAE,YAAY,CAG9B;IAEF,2BAA2B;aACX,IAAI,IAAI,IAAI;IAC5B,4BAA4B;aACZ,KAAK,IAAI,IAAI;IAEb,iBAAiB,IAAI,IAAI;CAI1C"}

package/development/core/base-elements.d.ts

@@ -0,0 +1,5 @@
+export * from './base-elements/action-base-element.js';
+export * from './base-elements/button-base-element.js';
+export * from './base-elements/link-base-element.js';
+export * from './base-elements/open-close-base-element.js';
+//# sourceMappingURL=base-elements.d.ts.map

package/development/core/base-elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-elements.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/base-elements.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC"}