@sbb-esta/lyne-elements 2.10.1 → 3.0.0-next.0

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;;;;;;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"}
+{"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

@@ -131,7 +131,6 @@ function isPotentiallyFocusable(element) {
 export {
   InteractivityChecker,
   IsFocusableConfig,
-  hasGeometry,
   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.js';\n\n/**\n * @deprecated Will be removed with next major version.\n */\nexport interface InterfaceInteractivityChecker {\n  isVisible(element: HTMLElement): boolean;\n}\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\n/**\n * @deprecated Will no longer be available with next major version.\n * TODO: remove export keyword\n */\nexport 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\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 an 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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"}
+//# 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.js';\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 an 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":";;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;MAkBa,kBAAiB;AAAA,EAA9B,cAAA;AAIS,SAAgB,mBAAY;AAAA,EAAA;AACpC;MAEY,qBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOxB,WAAW,SAAoB;AACpC,WAAO,QAAQ,aAAa,UAAU,KAAK,QAAQ,QAAQ,WAAW;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWjE,UAAU,SAAoB;AACnC,WAAO,YAAY,OAAO,KAAK,iBAAiB,OAAO,EAAE,eAAe;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUnE,WAAW,SAAoB;AAEpC,QAAI,UAAU;AACL,aAAA;AAAA,IAAA;AAGH,UAAA,WAAW,QAAQ,SAAS;AAC5B,UAAA,gBAAgB,iBAAiB,OAAO;AAE1C,QAAA,QAAQ,aAAa,iBAAiB,GAAG;AAC3C,aAAO,kBAAkB;AAAA,IAAA;AAGvB,QAAA,aAAa,YAAY,aAAa,UAAU;AAI3C,aAAA;AAAA,IAAA;AAIT,QAAI,YAAY,SAAS,CAAC,yBAAyB,OAAO,GAAG;AACpD,aAAA;AAAA,IAAA;AAGT,QAAI,aAAa,SAAS;AAGxB,UAAI,CAAC,QAAQ,aAAa,UAAU,GAAG;AAC9B,eAAA;AAAA,MAAA;AAIT,aAAO,kBAAkB;AAAA,IAAA;AAG3B,QAAI,aAAa,SAAS;AAKxB,UAAI,kBAAkB,IAAI;AACjB,eAAA;AAAA,MAAA;AAIT,UAAI,kBAAkB,MAAM;AACnB,eAAA;AAAA,MAAA;AAKF,aAAA,aAAa,QAAQ,aAAa,UAAU;AAAA,IAAA;AAGrD,WAAO,QAAQ,YAAY;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUtB,YAAY,SAAsB,QAA0B;AAGjE,WACE,uBAAuB,OAAO,KAC9B,CAAC,QAAQ,SACT,CAAC,KAAK,WAAW,OAAO,OACvB,iCAAQ,qBAAoB,KAAK,UAAU,OAAO;AAAA,EAAA;AAGxD;AAIY,MAAA,uBAAuB,IAAI;AAExC,SAAS,YAAY,SAAoB;AAGvC,SAAO,CAAC,EACN,QAAQ,eACR,QAAQ,gBACP,OAAO,QAAQ,mBAAmB,cAAc,QAAQ,eAAA,EAAiB;AAE9E;AAGA,SAAS,oBAAoB,SAAa;AAClC,QAAA,WAAW,QAAQ,SAAS;AAClC,SACE,aAAa,WACb,aAAa,YACb,aAAa,YACb,aAAa;AAEjB;AAGA,SAAS,cAAc,SAAoB;AACzC,SAAO,eAAe,OAAO,KAAK,QAAQ,QAAQ;AACpD;AAGA,SAAS,iBAAiB,SAAoB;AAC5C,SAAO,gBAAgB,OAAO,KAAK,QAAQ,aAAa,MAAM;AAChE;AAGA,SAAS,eAAe,SAAoB;AACnC,SAAA,QAAQ,SAAS,YAAA,KAAiB;AAC3C;AAGA,SAAS,gBAAgB,SAAoB;AACpC,SAAA,QAAQ,SAAS,YAAA,KAAiB;AAC3C;AAGA,SAAS,iBAAiB,SAAoB;AAC5C,MAAI,CAAC,QAAQ,aAAa,UAAU,KAAK,QAAQ,aAAa,QAAW;AAChE,WAAA;AAAA,EAAA;AAGH,QAAA,WAAW,QAAQ,aAAa,UAAU;AACzC,SAAA,CAAC,EAAE,YAAY,CAAC,MAAM,SAAS,UAAU,EAAE,CAAC;AACrD;AAMA,SAAS,iBAAiB,SAAoB;AACxC,MAAA,CAAC,iBAAiB,OAAO,GAAG;AACvB,WAAA;AAAA,EAAA;AAIT,QAAM,WAAW,SAAS,QAAQ,aAAa,UAAU,KAAK,IAAI,EAAE;AAE7D,SAAA,MAAM,QAAQ,IAAI,KAAK;AAChC;AAGA,SAAS,yBAAyB,SAAoB;AAC9C,QAAA,WAAW,QAAQ,SAAS;AAC5B,QAAA,YAAY,aAAa,WAAY,QAA6B;AAExE,SACE,cAAc,UACd,cAAc,cACd,aAAa,YACb,aAAa;AAEjB;AAMA,SAAS,uBAAuB,SAAoB;AAE9C,MAAA,cAAc,OAAO,GAAG;AACnB,WAAA;AAAA,EAAA;AAIP,SAAA,oBAAoB,OAAO,KAC3B,iBAAiB,OAAO,KACxB,QAAQ,aAAa,iBAAiB,KACtC,iBAAiB,OAAO;AAE5B;"}

package/development/core/a11y/live-announcer.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+export type AriaLivePoliteness = 'off' | 'polite' | 'assertive';
+/**
+ * Allows to announce messages to screen readers.
+ *
+ * Adapted from https://github.com/angular/components/blob/main/src/cdk/a11y/live-announcer/live-announcer.ts
+ */
+export declare class SbbLiveAnnouncer {
+    private _liveElement;
+    private _previousTimeout;
+    private _currentPromise;
+    private _currentResolve;
+    constructor();
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string): Promise<void>;
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param politeness The politeness of the announcer element.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string, politeness?: AriaLivePoliteness): Promise<void>;
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param duration Time in milliseconds after which to clear out the announcer element. Note
+     *   that this takes effect after the message has been added to the DOM, which can be up to
+     *   100ms after `announce` has been called.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string, duration?: number): Promise<void>;
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param politeness The politeness of the announcer element.
+     * @param duration Time in milliseconds after which to clear out the announcer element. Note
+     *   that this takes effect after the message has been added to the DOM, which can be up to
+     *   100ms after `announce` has been called.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string, politeness?: AriaLivePoliteness, duration?: number): Promise<void>;
+    /**
+     * Clears the current text from the announcer element. Can be used to prevent
+     * screen readers from reading the text out again while the user is going
+     * through the page landmarks.
+     */
+    clear(): void;
+    destroy(): void;
+    private _createLiveElement;
+}
+export declare const sbbLiveAnnouncer: SbbLiveAnnouncer;
+//# sourceMappingURL=live-announcer.d.ts.map

package/development/core/a11y/live-announcer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-announcer.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/a11y/live-announcer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,QAAQ,GAAG,WAAW,CAAC;AAIhE;;;;GAIG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,eAAe,CAA4B;IACnD,OAAO,CAAC,eAAe,CAA2B;;IAQlD;;;;OAIG;IACI,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAE/C;;;;;OAKG;IACI,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAEhF;;;;;;;OAOG;IACI,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAElE;;;;;;;;OAQG;IACI,QAAQ,CACb,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,kBAAkB,EAC/B,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC;IAkDhB;;;;OAIG;IACI,KAAK,IAAI,IAAI;IAMb,OAAO,IAAI,IAAI;IAQtB,OAAO,CAAC,kBAAkB;CAqB3B;AAED,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}

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

@@ -0,0 +1,87 @@
+import { isServer } from "lit";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+let uniqueIds = 0;
+class SbbLiveAnnouncer {
+  constructor() {
+    if (!isServer) {
+      this._liveElement = this._createLiveElement();
+    }
+  }
+  announce(message, ...args) {
+    if (isServer) {
+      return Promise.resolve();
+    }
+    const defaultOptions = {};
+    let politeness;
+    let duration;
+    if (args.length === 1 && typeof args[0] === "number") {
+      duration = args[0];
+    } else {
+      [politeness, duration] = args;
+    }
+    this.clear();
+    clearTimeout(this._previousTimeout);
+    politeness ?? (politeness = (defaultOptions == null ? void 0 : defaultOptions.politeness) ?? "polite");
+    duration ?? (duration = defaultOptions == null ? void 0 : defaultOptions.duration);
+    this._liveElement.setAttribute("aria-live", politeness);
+    if (!this._currentPromise) {
+      this._currentPromise = new Promise((resolve) => this._currentResolve = resolve);
+    }
+    clearTimeout(this._previousTimeout);
+    this._previousTimeout = setTimeout(() => {
+      var _a;
+      this._liveElement.textContent = message;
+      if (typeof duration === "number") {
+        this._previousTimeout = setTimeout(() => this.clear(), duration);
+      }
+      (_a = this._currentResolve) == null ? void 0 : _a.call(this);
+      this._currentPromise = this._currentResolve = void 0;
+    }, 100);
+    return this._currentPromise;
+  }
+  /**
+   * Clears the current text from the announcer element. Can be used to prevent
+   * screen readers from reading the text out again while the user is going
+   * through the page landmarks.
+   */
+  clear() {
+    if (this._liveElement) {
+      this._liveElement.textContent = "";
+    }
+  }
+  destroy() {
+    var _a, _b;
+    clearTimeout(this._previousTimeout);
+    (_a = this._liveElement) == null ? void 0 : _a.remove();
+    this._liveElement = null;
+    (_b = this._currentResolve) == null ? void 0 : _b.call(this);
+    this._currentPromise = this._currentResolve = void 0;
+  }
+  _createLiveElement() {
+    const elementClass = "sbb-live-announcer-element";
+    const previousElements = document.getElementsByClassName(elementClass);
+    const liveEl = document.createElement("div");
+    for (let i = 0; i < previousElements.length; i++) {
+      previousElements[i].remove();
+    }
+    liveEl.classList.add(elementClass);
+    liveEl.classList.add("sbb-screen-reader-only");
+    liveEl.setAttribute("aria-atomic", "true");
+    liveEl.setAttribute("aria-live", "polite");
+    liveEl.id = `sbb-live-announcer-${uniqueIds++}`;
+    document.body.appendChild(liveEl);
+    return liveEl;
+  }
+}
+const sbbLiveAnnouncer = new SbbLiveAnnouncer();
+export {
+  SbbLiveAnnouncer,
+  sbbLiveAnnouncer
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"live-announcer.js","sources":["../../../../../src/elements/core/a11y/live-announcer.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport { isServer } from 'lit';\n\nexport type AriaLivePoliteness = 'off' | 'polite' | 'assertive';\n\nlet uniqueIds = 0;\n\n/**\n * Allows to announce messages to screen readers.\n *\n * Adapted from https://github.com/angular/components/blob/main/src/cdk/a11y/live-announcer/live-announcer.ts\n */\nexport class SbbLiveAnnouncer {\n  private _liveElement!: HTMLElement;\n  private _previousTimeout: ReturnType<typeof setTimeout> | undefined;\n  private _currentPromise: Promise<void> | undefined;\n  private _currentResolve: (() => void) | undefined;\n\n  public constructor() {\n    if (!isServer) {\n      this._liveElement = this._createLiveElement();\n    }\n  }\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, politeness?: AriaLivePoliteness): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, duration?: number): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(\n    message: string,\n    politeness?: AriaLivePoliteness,\n    duration?: number,\n  ): Promise<void>;\n\n  public announce(message: string, ...args: any[]): Promise<void> {\n    if (isServer) {\n      return Promise.resolve();\n    }\n\n    // TODO: Decide whether to have global options.\n    const defaultOptions = {} as { politeness?: AriaLivePoliteness; duration?: number };\n    let politeness: AriaLivePoliteness | undefined;\n    let duration: number | undefined;\n\n    if (args.length === 1 && typeof args[0] === 'number') {\n      duration = args[0];\n    } else {\n      [politeness, duration] = args;\n    }\n\n    this.clear();\n    clearTimeout(this._previousTimeout);\n\n    politeness ??= defaultOptions?.politeness ?? 'polite';\n    duration ??= defaultOptions?.duration;\n\n    this._liveElement.setAttribute('aria-live', politeness);\n\n    // This 100ms timeout is necessary for some browser + screen-reader combinations:\n    // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.\n    // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a\n    //   second time without clearing and then using a non-zero delay.\n    // (using JAWS 17 at time of this writing).\n    if (!this._currentPromise) {\n      this._currentPromise = new Promise((resolve) => (this._currentResolve = resolve));\n    }\n\n    clearTimeout(this._previousTimeout);\n    this._previousTimeout = setTimeout(() => {\n      this._liveElement.textContent = message;\n\n      if (typeof duration === 'number') {\n        this._previousTimeout = setTimeout(() => this.clear(), duration);\n      }\n\n      this._currentResolve?.();\n      this._currentPromise = this._currentResolve = undefined;\n    }, 100);\n\n    return this._currentPromise;\n  }\n\n  /**\n   * Clears the current text from the announcer element. Can be used to prevent\n   * screen readers from reading the text out again while the user is going\n   * through the page landmarks.\n   */\n  public clear(): void {\n    if (this._liveElement) {\n      this._liveElement.textContent = '';\n    }\n  }\n\n  public destroy(): void {\n    clearTimeout(this._previousTimeout);\n    this._liveElement?.remove();\n    this._liveElement = null!;\n    this._currentResolve?.();\n    this._currentPromise = this._currentResolve = undefined;\n  }\n\n  private _createLiveElement(): HTMLElement {\n    const elementClass = 'sbb-live-announcer-element';\n    const previousElements = document.getElementsByClassName(elementClass);\n    const liveEl = document.createElement('div');\n\n    // Remove any old containers. This can happen when coming in from a server-side-rendered page.\n    for (let i = 0; i < previousElements.length; i++) {\n      previousElements[i].remove();\n    }\n\n    liveEl.classList.add(elementClass);\n    liveEl.classList.add('sbb-screen-reader-only');\n\n    liveEl.setAttribute('aria-atomic', 'true');\n    liveEl.setAttribute('aria-live', 'polite');\n    liveEl.id = `sbb-live-announcer-${uniqueIds++}`;\n\n    document.body.appendChild(liveEl);\n\n    return liveEl;\n  }\n}\n\nexport const sbbLiveAnnouncer = new SbbLiveAnnouncer();\n"],"names":[],"mappings":";AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,IAAI,YAAY;MAOH,iBAAgB;AAAA,EAM3B,cAAA;AACE,QAAI,CAAC,UAAU;AACR,WAAA,eAAe,KAAK;;EAC3B;AAAA,EA2CK,SAAS,YAAoB,MAAW;AAC7C,QAAI,UAAU;AACZ,aAAO,QAAQ,QAAO;AAAA,IAAA;AAIxB,UAAM,iBAAiB,CAAA;AACnB,QAAA;AACA,QAAA;AAEJ,QAAI,KAAK,WAAW,KAAK,OAAO,KAAK,CAAC,MAAM,UAAU;AACpD,iBAAW,KAAK,CAAC;AAAA,IAAA,OACZ;AACJ,OAAA,YAAY,QAAQ,IAAI;AAAA,IAAA;AAG3B,SAAK,MAAK;AACV,iBAAa,KAAK,gBAAgB;AAElC,iCAAe,iDAAgB,eAAc;AAC7C,4BAAa,iDAAgB;AAExB,SAAA,aAAa,aAAa,aAAa,UAAU;AAOlD,QAAA,CAAC,KAAK,iBAAiB;AACzB,WAAK,kBAAkB,IAAI,QAAQ,CAAC,YAAa,KAAK,kBAAkB,OAAQ;AAAA,IAAA;AAGlF,iBAAa,KAAK,gBAAgB;AAC7B,SAAA,mBAAmB,WAAW,MAAK;;AACtC,WAAK,aAAa,cAAc;AAE5B,UAAA,OAAO,aAAa,UAAU;AAChC,aAAK,mBAAmB,WAAW,MAAM,KAAK,SAAS,QAAQ;AAAA,MAAA;AAGjE,iBAAK,oBAAL;AACK,WAAA,kBAAkB,KAAK,kBAAkB;AAAA,OAC7C,GAAG;AAEN,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQP,QAAK;AACV,QAAI,KAAK,cAAc;AACrB,WAAK,aAAa,cAAc;AAAA,IAAA;AAAA,EAClC;AAAA,EAGK,UAAO;;AACZ,iBAAa,KAAK,gBAAgB;AAClC,eAAK,iBAAL,mBAAmB;AACnB,SAAK,eAAe;AACpB,eAAK,oBAAL;AACK,SAAA,kBAAkB,KAAK,kBAAkB;AAAA,EAAA;AAAA,EAGxC,qBAAkB;AACxB,UAAM,eAAe;AACf,UAAA,mBAAmB,SAAS,uBAAuB,YAAY;AAC/D,UAAA,SAAS,SAAS,cAAc,KAAK;AAG3C,aAAS,IAAI,GAAG,IAAI,iBAAiB,QAAQ,KAAK;AAC/B,uBAAA,CAAC,EAAE;;AAGf,WAAA,UAAU,IAAI,YAAY;AAC1B,WAAA,UAAU,IAAI,wBAAwB;AAEtC,WAAA,aAAa,eAAe,MAAM;AAClC,WAAA,aAAa,aAAa,QAAQ;AAClC,WAAA,KAAK,sBAAsB,WAAW;AAEpC,aAAA,KAAK,YAAY,MAAM;AAEzB,WAAA;AAAA,EAAA;AAEV;AAEY,MAAA,mBAAmB,IAAI;"}

package/development/core/a11y.d.ts

@@ -8,4 +8,5 @@ export * from './a11y/focus.js';
 export * from './a11y/focus-trap-controller.js';
 export * from './a11y/interactivity-checker.js';
 export * from './a11y/input-modality-detector.js';
+export * from './a11y/live-announcer.js';
 //# sourceMappingURL=a11y.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"a11y.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/a11y.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"a11y.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/a11y.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC"}

package/development/core/a11y.js

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

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

@@ -1,5 +1,6 @@
 import { LitElement, TemplateResult } from 'lit';
-export declare abstract class SbbActionBaseElement extends LitElement {
+declare const SbbActionBaseElement_base: import('../mixins.js').AbstractConstructor<import('../mixins.js').SbbElementInternalsMixinType> & typeof LitElement & import('../mixins.js').SbbElementInternalsConstructor;
+export declare abstract class SbbActionBaseElement extends SbbActionBaseElement_base {
     protected get maybeDisabled(): boolean | undefined;
     protected get maybeDisabledInteractive(): boolean | undefined;
     connectedCallback(): void;
@@ -9,4 +10,5 @@ export declare abstract class SbbActionBaseElement extends LitElement {
     /** Default render method for button-like components. */
     protected render(): TemplateResult;
 }
+export {};
 //# sourceMappingURL=action-base-element.d.ts.map

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

@@ -1 +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,8BAIe,oBAAqB,SAAQ,UAAU;IACpD,SAAS,KAAK,aAAa,IAAI,OAAO,GAAG,SAAS,CAGjD;IAED,SAAS,KAAK,wBAAwB,IAAI,OAAO,GAAG,SAAS,CAE5D;IAEe,iBAAiB,IAAI,IAAI;IAezC,SAAS,CAAC,sBAAsB,IAAI,IAAI;IAexC,6DAA6D;IAC7D,SAAS,CAAC,cAAc,IAAI,cAAc;IAI1C,wDAAwD;cACrC,MAAM,IAAI,cAAc;CAG5C"}
+{"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;;AAgB5D,8BAIe,oBAAqB,SAAQ,yBAAoC;IAC9E,SAAS,KAAK,aAAa,IAAI,OAAO,GAAG,SAAS,CAGjD;IAED,SAAS,KAAK,wBAAwB,IAAI,OAAO,GAAG,SAAS,CAE5D;IAEe,iBAAiB,IAAI,IAAI;IAezC,SAAS,CAAC,sBAAsB,IAAI,IAAI;IAexC,6DAA6D;IAC7D,SAAS,CAAC,cAAc,IAAI,cAAc;IAI1C,wDAAwD;cACrC,MAAM,IAAI,cAAc;CAG5C"}

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

@@ -1,6 +1,7 @@
 import { __esDecorate, __runInitializers } from "tslib";
 import { LitElement, html } from "lit";
 import { hostAttributes } from "../decorators.js";
+import { SbbElementInternalsMixin } from "../mixins.js";
 let SbbActionBaseElement = (() => {
   var _a;
   let _classDecorators = [hostAttributes({
@@ -9,7 +10,7 @@ let SbbActionBaseElement = (() => {
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
-  let _classSuper = LitElement;
+  let _classSuper = SbbElementInternalsMixin(LitElement);
   _a = class extends _classSuper {
     get maybeDisabled() {
       const maybeDisabled = this;
@@ -59,4 +60,4 @@ let SbbActionBaseElement = (() => {
 export {
   SbbActionBaseElement
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -2,25 +2,11 @@ import { FormRestoreReason, FormRestoreState } from '../mixins.js';
 import { SbbActionBaseElement } from './action-base-element.js';
 /** Enumeration for type attribute in <button> HTML tag. */
 export type SbbButtonType = 'button' | 'reset' | 'submit';
-declare const SbbButtonBaseElement_base: import('../mixins.js').AbstractConstructor<import('../mixins.js').SbbFormAssociatedMixinType<string>> & typeof SbbActionBaseElement;
+declare const SbbButtonLikeBaseElement_base: import('../mixins.js').AbstractConstructor<import('../mixins.js').SbbFormAssociatedMixinType> & typeof SbbActionBaseElement;
 /** Button base class. */
-export declare abstract class SbbButtonBaseElement extends SbbButtonBaseElement_base {
-    private readonly _elementsOnWhichEnterPressTriggersSubmit;
-    /**
-     * The type attribute to use for the button.
-     * @default 'button'
-     */
-    set type(name: SbbButtonType);
-    get type(): SbbButtonType;
-    /** The `<form>` element to associate the button with. */
-    set form(value: string);
-    get form(): HTMLFormElement | null;
-    private _formId;
+export declare abstract class SbbButtonLikeBaseElement extends SbbButtonLikeBaseElement_base {
+    static readonly role: ElementInternals['role'];
     constructor();
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    private _handleButtonClick;
-    private _requestSubmit;
     /**
      * Prevents scrolling from pressing Space, when the event target is an action element.
      * Also sets data-active attribute.
@@ -35,9 +21,30 @@ export declare abstract class SbbButtonBaseElement extends SbbButtonBaseElement_
      * @param event The origin event.
      */
     private _dispatchClickEventOnSpaceKeyup;
-    private _formKeyDown;
     private _dispatchClickEvent;
     attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+}
+/** Button base class. */
+export declare abstract class SbbButtonBaseElement extends SbbButtonLikeBaseElement {
+    private readonly _elementsOnWhichEnterPressTriggersSubmit;
+    /** Value of the form element. */
+    accessor value: string;
+    /**
+     * The type attribute to use for the button.
+     * @default 'button'
+     */
+    set type(name: SbbButtonType);
+    get type(): SbbButtonType;
+    /** The `<form>` element to associate the button with. */
+    set form(value: string);
+    get form(): HTMLFormElement | null;
+    private _formId;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _handleButtonClick;
+    private _requestSubmit;
+    private _formKeyDown;
     /**
      * Intentionally empty, as buttons are not targeted by form reset
      * @internal

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

@@ -1 +1 @@
-{"version":3,"file":"button-base-element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/button-base-element.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAEtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEhE,2DAA2D;AAC3D,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;;AAE1D,yBAAyB;AACzB,8BAKe,oBAAqB,SAAQ,yBAA4C;IACtF,OAAO,CAAC,QAAQ,CAAC,wCAAwC,CAA+B;IAExF;;;OAGG;IACH,IACoB,IAAI,CAAC,IAAI,EAAE,aAAa,EAE3C;IACD,IAAoB,IAAI,IAAI,aAAa,CAExC;IAED,yDAAyD;IACzD,IACoB,IAAI,CAAC,KAAK,EAAE,MAAM,EAGrC;IACD,IAAoB,IAAI,IAAI,eAAe,GAAG,IAAI,CAQjD;IACD,OAAO,CAAC,OAAO,CAAc;;IA4Bb,iBAAiB,IAAI,IAAI;IAMzB,oBAAoB,IAAI,IAAI;IAM5C,OAAO,CAAC,kBAAkB,CAaxB;IAEF,OAAO,CAAC,cAAc;IAgBtB;;;;OAIG;IACH,OAAO,CAAC,4BAA4B,CAKlC;IAEF,OAAO,CAAC,mBAAmB,CAEzB;IAEF;;;;;OAKG;IACH,OAAO,CAAC,+BAA+B,CAKrC;IAEF,OAAO,CAAC,YAAY,CA6BlB;IAEF,OAAO,CAAC,mBAAmB,CAezB;IAEc,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,IAAI;IAMP;;;OAGG;IACa,iBAAiB,IAAI,IAAI;IAEzC;;;OAGG;IACa,wBAAwB,CACtC,MAAM,EAAE,gBAAgB,GAAG,IAAI,EAC/B,OAAO,EAAE,iBAAiB,GACzB,IAAI;IAEP;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,IAAI;CAClC"}
+{"version":3,"file":"button-base-element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/button-base-element.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAEtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEhE,2DAA2D;AAC3D,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;;AAE1D,yBAAyB;AACzB,8BAKe,wBAAyB,SAAQ,6BAA4C;IAC1F,gBAAgC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAY;;IAwB1E;;;;OAIG;IACH,OAAO,CAAC,4BAA4B,CAKlC;IAEF,OAAO,CAAC,mBAAmB,CAEzB;IAEF;;;;;OAKG;IACH,OAAO,CAAC,+BAA+B,CAKrC;IAEF,OAAO,CAAC,mBAAmB,CAezB;IAEc,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,IAAI;CAKR;AAED,yBAAyB;AACzB,8BAAsB,oBAAqB,SAAQ,wBAAwB;IACzE,OAAO,CAAC,QAAQ,CAAC,wCAAwC,CAIvD;IAEF,iCAAiC;IACjC,SAEgB,KAAK,EAAE,MAAM,CAAM;IAEnC;;;OAGG;IACH,IACoB,IAAI,CAAC,IAAI,EAAE,aAAa,EAE3C;IACD,IAAoB,IAAI,IAAI,aAAa,CAExC;IAED,yDAAyD;IACzD,IACoB,IAAI,CAAC,KAAK,EAAE,MAAM,EAGrC;IACD,IAAoB,IAAI,IAAI,eAAe,GAAG,IAAI,CAQjD;IACD,OAAO,CAAC,OAAO,CAAc;;IAQb,iBAAiB,IAAI,IAAI;IAMzB,oBAAoB,IAAI,IAAI;IAM5C,OAAO,CAAC,kBAAkB,CAaxB;IAEF,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,YAAY,CA6BlB;IAEF;;;OAGG;IACa,iBAAiB,IAAI,IAAI;IAEzC;;;OAGG;IACa,wBAAwB,CACtC,MAAM,EAAE,gBAAgB,GAAG,IAAI,EAC/B,OAAO,EAAE,iBAAiB,GACzB,IAAI;IAEP;;;;OAIG;cACgB,eAAe,IAAI,IAAI;CAC3C"}