@sbb-esta/lyne-elements-dev 5.0.0-next.3-dev.1779195190 → 5.0.0-next.3-dev.1779200097

package/development/{overlay.component-rFmitc_r.js → overlay.component-YSCuGeme.js}

@@ -139,12 +139,9 @@ var SbbOverlayElement = (() => {
 			this.removeInstanceFromGlobalCollection();
 			if (!overlayRefs.length) this.scrollHandler.enableScroll();
 			this.escapableOverlayController.disconnect();
-			this.dispatchCloseEvent({
-				returnValue: this.returnValue,
-				closeTarget: this.overlayCloseElement
-			});
+			this.dispatchCloseEvent();
 		}
-		dispatchBeforeCloseEvent(_detail) {
+		dispatchBeforeCloseEvent() {
 			/** @type {SbbOverlayCloseEvent} Emits whenever the component begins the closing transition. Can be canceled. */
 			return this.dispatchEvent(new SbbOverlayCloseEvent("beforeclose", {
 				cancelable: true,
@@ -153,7 +150,7 @@ var SbbOverlayElement = (() => {
 				result: this.returnValue
 			}));
 		}
-		dispatchCloseEvent(_detail) {
+		dispatchCloseEvent() {
 			/** @type {SbbOverlayCloseEvent} Emits whenever the component is closed. */
 			return this.dispatchEvent(new SbbOverlayCloseEvent("close", {
 				closeAttribute: this.closeAttribute,
@@ -203,4 +200,4 @@ var SbbOverlayElement = (() => {
 //#endregion
 export { SbbOverlayElement as t };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay.component-rFmitc_r.js","names":[],"sources":["../../../src/elements/overlay/overlay.scss?inline","../../../src/elements/overlay/overlay.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  --_sbb-overlay-padding-block: calc(\n    var(--sbb-spacing-fixed-14x) + var(--sbb-spacing-responsive-l)\n  );\n  --sbb-overlay-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n\n  display: var(--sbb-overlay-display);\n  position: fixed;\n  inset: var(--sbb-overlay-inset);\n  z-index: var(--sbb-overlay-z-index, var(--sbb-overlay-default-z-index));\n}\n\n:host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) {\n  --sbb-overlay-display: block;\n  --sbb-overlay-container-display: flex;\n}\n\n:host(:is(:state(state-opening), :state(state-opened))) {\n  --sbb-overlay-pointer-events: all;\n}\n\n:host([negative]) {\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);\n  --sbb-overlay-color: var(--sbb-color-1-negative);\n  --sbb-overlay-background-color: var(--sbb-background-color-3-negative);\n}\n\n:host(:not(:state(state-closed))) {\n  --sbb-overlay-inset: 0;\n}\n\n.sbb-overlay__container {\n  background-color: var(--sbb-overlay-background-color);\n  pointer-events: var(--sbb-overlay-pointer-events);\n  display: var(--sbb-overlay-container-display);\n  align-items: center;\n  position: fixed;\n  inset: var(--sbb-overlay-inset);\n\n  :host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) & {\n    animation: {\n      name: open;\n      duration: var(--sbb-overlay-animation-duration);\n      timing-function: var(--sbb-overlay-animation-easing);\n    }\n  }\n\n  :host(:state(state-closing)) & {\n    pointer-events: none;\n    animation-name: close;\n  }\n}\n\n.sbb-overlay {\n  position: absolute;\n  inset-inline: 0;\n  margin: auto;\n  padding: 0;\n  border: none;\n  height: var(--sbb-overlay-height);\n  color: var(--sbb-overlay-color);\n\n  :host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) & {\n    animation: {\n      name: open-move-in;\n      duration: var(--sbb-overlay-animation-duration);\n      timing-function: var(--sbb-overlay-animation-easing);\n    }\n  }\n\n  :host(:state(state-closing)) & {\n    animation-name: close-move-out;\n  }\n}\n\n.sbb-overlay__wrapper {\n  display: flex;\n  flex-direction: column;\n  width: 100%;\n  height: var(--sbb-overlay-height);\n  outline: none;\n  position: fixed;\n\n  @include sbb.mq($from: large) {\n    position: sticky;\n    inset-block-start: 0;\n    height: auto;\n  }\n}\n\n.sbb-overlay__header {\n  position: absolute;\n  inset-inline-start: 0;\n  display: flex;\n  pointer-events: none;\n  align-items: start;\n  justify-content: space-between;\n  width: 100%;\n  padding: var(--sbb-spacing-responsive-xs);\n  padding-block-end: 0;\n  z-index: 1;\n\n  * {\n    pointer-events: all;\n  }\n}\n\n.sbb-overlay__close {\n  margin-inline-start: auto;\n}\n\n.sbb-overlay__content {\n  height: 100vh;\n  overflow: auto;\n  -webkit-overflow-scrolling: touch;\n}\n\n.sbb-overlay__content-container {\n  padding-block: var(--_sbb-overlay-padding-block);\n}\n\n// It is necessary to use animations with keyframes instead of transitions in order not to alter\n// the default `display: block` of the modal otherwise it causes several problems,\n// especially for accessibility.\n@keyframes open {\n  from {\n    opacity: 0;\n  }\n\n  to {\n    opacity: 1;\n  }\n}\n\n@keyframes open-move-in {\n  from {\n    transform: translateY(var(--sbb-spacing-fixed-4x));\n  }\n\n  to {\n    transform: translateY(0%);\n  }\n}\n\n@keyframes close {\n  from {\n    opacity: 1;\n  }\n\n  to {\n    opacity: 0;\n  }\n}\n\n@keyframes close-move-out {\n  from {\n    transform: translateY(0%);\n  }\n\n  to {\n    transform: translateY(var(--sbb-spacing-fixed-4x));\n  }\n}\n","import { type CSSResultGroup, type PropertyValues, type TemplateResult, unsafeCSS } from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\nimport { html } from 'lit/static-html.js';\n\nimport { SbbSecondaryButtonElement } from '../button.pure.ts';\nimport { SbbContainerElement } from '../container.pure.ts';\nimport {\n  forceType,\n  forwardEvent,\n  i18nCloseDialog,\n  isZeroAnimationDuration,\n  type SbbElementType,\n  type SbbOverlayCloseEventDetails,\n  scrollbarStyles,\n} from '../core.ts';\n\nimport {\n  overlayRefs,\n  SbbOverlayBaseElement,\n  SbbOverlayCloseEvent,\n} from './overlay-base-element.ts';\nimport style from './overlay.scss?inline';\n\n/**\n * It displays an interactive overlay element.\n *\n * @slot - Use the unnamed slot to provide a content for the overlay.\n * @cssprop [--sbb-overlay-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n */\nexport class SbbOverlayElement extends SbbOverlayBaseElement {\n  public static override readonly elementName: string = 'sbb-overlay';\n  public static override elementDependencies: SbbElementType[] = [\n    SbbSecondaryButtonElement,\n    SbbContainerElement,\n  ];\n  public static override styles: CSSResultGroup = [scrollbarStyles, unsafeCSS(style)];\n\n  // TODO: fix using ...super.events requires: https://github.com/sbb-design-systems/lyne-components/issues/2600\n  public static override readonly events = {\n    beforeopen: 'beforeopen',\n    open: 'open',\n    beforeclose: 'beforeclose',\n    close: 'close',\n  } as const;\n\n  /**\n   * Whether to allow the overlay content to stretch to full width.\n   * By default, the content has the appropriate page size.\n   */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor expanded: boolean = false;\n\n  /** This will be forwarded as aria-label to the close button element. */\n  @forceType()\n  @property({ attribute: 'accessibility-close-label' })\n  public accessor accessibilityCloseLabel: string = '';\n\n  protected closeAttribute: string = 'sbb-overlay-close';\n  private _overlayContentElement: HTMLElement | null = null;\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    // If the component is already open on firstUpdate, announce the title\n    if (this.isOpen) {\n      this.setAriaLiveRefContent();\n    }\n  }\n\n  protected isZeroAnimationDuration(): boolean {\n    return isZeroAnimationDuration(this, '--sbb-overlay-animation-duration');\n  }\n\n  protected handleOpening(): void {\n    this.state = 'opened';\n    this.inertController.activate();\n    this.focusTrapController.focusInitialElement();\n    // Use timeout to read label after focused element\n    setTimeout(() => this.setAriaLiveRefContent(this.accessibilityLabel));\n    this.focusTrapController.enabled = true;\n    this.dispatchOpenEvent();\n  }\n\n  protected override handleClosing(): void {\n    this._overlayContentElement?.scrollTo(0, 0);\n    this.state = 'closed';\n    this.hidePopover?.();\n    this.inertController.deactivate();\n    if (!this.skipFocusRestoration) {\n      // Manually focus last focused element\n      this.lastFocusedElement?.focus();\n    }\n    this.openOverlayController?.abort();\n    this.focusTrapController.enabled = false;\n    this.removeInstanceFromGlobalCollection();\n    // Enable scrolling for content below the overlay if no overlay is open\n    if (!overlayRefs.length) {\n      this.scrollHandler.enableScroll();\n    }\n    this.escapableOverlayController.disconnect();\n    this.dispatchCloseEvent({\n      returnValue: this.returnValue,\n      closeTarget: this.overlayCloseElement,\n    });\n  }\n\n  // TODO: remove parameter `detail`\n  protected override dispatchBeforeCloseEvent(_detail?: SbbOverlayCloseEventDetails): boolean {\n    /** @type {SbbOverlayCloseEvent} Emits whenever the component begins the closing transition. Can be canceled. */\n    return this.dispatchEvent(\n      new SbbOverlayCloseEvent('beforeclose', {\n        cancelable: true,\n        closeAttribute: this.closeAttribute,\n        closeTarget: this.overlayCloseElement,\n        result: this.returnValue,\n      }),\n    );\n  }\n\n  // TODO: remove parameter `detail`\n  protected override dispatchCloseEvent(_detail?: SbbOverlayCloseEventDetails): boolean {\n    /** @type {SbbOverlayCloseEvent} Emits whenever the component is closed. */\n    return this.dispatchEvent(\n      new SbbOverlayCloseEvent('close', {\n        closeAttribute: this.closeAttribute,\n        closeTarget: this.overlayCloseElement,\n        result: this.returnValue,\n      }),\n    );\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-overlay__container\" @animationend=${this.onOverlayAnimationEnd}>\n        <div class=\"sbb-overlay\">\n          <div\n            @click=${(event: Event) => this.closeOnSbbOverlayCloseClick(event)}\n            class=\"sbb-overlay__wrapper\"\n          >\n            <div class=\"sbb-overlay__header\">\n              <sbb-secondary-button\n                class=\"sbb-overlay__close\"\n                aria-label=\"${this.accessibilityCloseLabel ||\n                i18nCloseDialog[this.language.current]}\"\n                ?negative=${this.negative}\n                size=\"m\"\n                icon-name=\"cross-small\"\n                sbb-overlay-close\n              ></sbb-secondary-button>\n            </div>\n            <div\n              class=\"sbb-overlay__content ${this.negative\n                ? 'sbb-scrollbar-negative'\n                : 'sbb-scrollbar'}\"\n              ${ref((el?: Element) => (this._overlayContentElement = el as HTMLDivElement))}\n              @scroll=${(e: Event) => forwardEvent(e, document)}\n            >\n              <sbb-container\n                class=\"sbb-overlay__content-container\"\n                ?expanded=${this.expanded}\n                color=\"transparent\"\n              >\n                <slot></slot>\n              </sbb-container>\n            </div>\n          </div>\n        </div>\n      </div>\n      <span class=\"sbb-screen-reader-only\" aria-live=\"polite\"></span>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-overlay': SbbOverlayElement;\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay.component-YSCuGeme.js","names":[],"sources":["../../../src/elements/overlay/overlay.scss?inline","../../../src/elements/overlay/overlay.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  --_sbb-overlay-padding-block: calc(\n    var(--sbb-spacing-fixed-14x) + var(--sbb-spacing-responsive-l)\n  );\n  --sbb-overlay-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n\n  display: var(--sbb-overlay-display);\n  position: fixed;\n  inset: var(--sbb-overlay-inset);\n  z-index: var(--sbb-overlay-z-index, var(--sbb-overlay-default-z-index));\n}\n\n:host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) {\n  --sbb-overlay-display: block;\n  --sbb-overlay-container-display: flex;\n}\n\n:host(:is(:state(state-opening), :state(state-opened))) {\n  --sbb-overlay-pointer-events: all;\n}\n\n:host([negative]) {\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);\n  --sbb-overlay-color: var(--sbb-color-1-negative);\n  --sbb-overlay-background-color: var(--sbb-background-color-3-negative);\n}\n\n:host(:not(:state(state-closed))) {\n  --sbb-overlay-inset: 0;\n}\n\n.sbb-overlay__container {\n  background-color: var(--sbb-overlay-background-color);\n  pointer-events: var(--sbb-overlay-pointer-events);\n  display: var(--sbb-overlay-container-display);\n  align-items: center;\n  position: fixed;\n  inset: var(--sbb-overlay-inset);\n\n  :host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) & {\n    animation: {\n      name: open;\n      duration: var(--sbb-overlay-animation-duration);\n      timing-function: var(--sbb-overlay-animation-easing);\n    }\n  }\n\n  :host(:state(state-closing)) & {\n    pointer-events: none;\n    animation-name: close;\n  }\n}\n\n.sbb-overlay {\n  position: absolute;\n  inset-inline: 0;\n  margin: auto;\n  padding: 0;\n  border: none;\n  height: var(--sbb-overlay-height);\n  color: var(--sbb-overlay-color);\n\n  :host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) & {\n    animation: {\n      name: open-move-in;\n      duration: var(--sbb-overlay-animation-duration);\n      timing-function: var(--sbb-overlay-animation-easing);\n    }\n  }\n\n  :host(:state(state-closing)) & {\n    animation-name: close-move-out;\n  }\n}\n\n.sbb-overlay__wrapper {\n  display: flex;\n  flex-direction: column;\n  width: 100%;\n  height: var(--sbb-overlay-height);\n  outline: none;\n  position: fixed;\n\n  @include sbb.mq($from: large) {\n    position: sticky;\n    inset-block-start: 0;\n    height: auto;\n  }\n}\n\n.sbb-overlay__header {\n  position: absolute;\n  inset-inline-start: 0;\n  display: flex;\n  pointer-events: none;\n  align-items: start;\n  justify-content: space-between;\n  width: 100%;\n  padding: var(--sbb-spacing-responsive-xs);\n  padding-block-end: 0;\n  z-index: 1;\n\n  * {\n    pointer-events: all;\n  }\n}\n\n.sbb-overlay__close {\n  margin-inline-start: auto;\n}\n\n.sbb-overlay__content {\n  height: 100vh;\n  overflow: auto;\n  -webkit-overflow-scrolling: touch;\n}\n\n.sbb-overlay__content-container {\n  padding-block: var(--_sbb-overlay-padding-block);\n}\n\n// It is necessary to use animations with keyframes instead of transitions in order not to alter\n// the default `display: block` of the modal otherwise it causes several problems,\n// especially for accessibility.\n@keyframes open {\n  from {\n    opacity: 0;\n  }\n\n  to {\n    opacity: 1;\n  }\n}\n\n@keyframes open-move-in {\n  from {\n    transform: translateY(var(--sbb-spacing-fixed-4x));\n  }\n\n  to {\n    transform: translateY(0%);\n  }\n}\n\n@keyframes close {\n  from {\n    opacity: 1;\n  }\n\n  to {\n    opacity: 0;\n  }\n}\n\n@keyframes close-move-out {\n  from {\n    transform: translateY(0%);\n  }\n\n  to {\n    transform: translateY(var(--sbb-spacing-fixed-4x));\n  }\n}\n","import { type CSSResultGroup, type PropertyValues, type TemplateResult, unsafeCSS } from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\nimport { html } from 'lit/static-html.js';\n\nimport { SbbSecondaryButtonElement } from '../button.pure.ts';\nimport { SbbContainerElement } from '../container.pure.ts';\nimport {\n  forceType,\n  forwardEvent,\n  i18nCloseDialog,\n  isZeroAnimationDuration,\n  type SbbElementType,\n  scrollbarStyles,\n} from '../core.ts';\n\nimport {\n  overlayRefs,\n  SbbOverlayBaseElement,\n  SbbOverlayCloseEvent,\n} from './overlay-base-element.ts';\nimport style from './overlay.scss?inline';\n\n/**\n * It displays an interactive overlay element.\n *\n * @slot - Use the unnamed slot to provide a content for the overlay.\n * @cssprop [--sbb-overlay-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n */\nexport class SbbOverlayElement extends SbbOverlayBaseElement {\n  public static override readonly elementName: string = 'sbb-overlay';\n  public static override elementDependencies: SbbElementType[] = [\n    SbbSecondaryButtonElement,\n    SbbContainerElement,\n  ];\n  public static override styles: CSSResultGroup = [scrollbarStyles, unsafeCSS(style)];\n\n  // TODO: fix using ...super.events requires: https://github.com/sbb-design-systems/lyne-components/issues/2600\n  public static override readonly events = {\n    beforeopen: 'beforeopen',\n    open: 'open',\n    beforeclose: 'beforeclose',\n    close: 'close',\n  } as const;\n\n  /**\n   * Whether to allow the overlay content to stretch to full width.\n   * By default, the content has the appropriate page size.\n   */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor expanded: boolean = false;\n\n  /** This will be forwarded as aria-label to the close button element. */\n  @forceType()\n  @property({ attribute: 'accessibility-close-label' })\n  public accessor accessibilityCloseLabel: string = '';\n\n  protected closeAttribute: string = 'sbb-overlay-close';\n  private _overlayContentElement: HTMLElement | null = null;\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    // If the component is already open on firstUpdate, announce the title\n    if (this.isOpen) {\n      this.setAriaLiveRefContent();\n    }\n  }\n\n  protected isZeroAnimationDuration(): boolean {\n    return isZeroAnimationDuration(this, '--sbb-overlay-animation-duration');\n  }\n\n  protected handleOpening(): void {\n    this.state = 'opened';\n    this.inertController.activate();\n    this.focusTrapController.focusInitialElement();\n    // Use timeout to read label after focused element\n    setTimeout(() => this.setAriaLiveRefContent(this.accessibilityLabel));\n    this.focusTrapController.enabled = true;\n    this.dispatchOpenEvent();\n  }\n\n  protected override handleClosing(): void {\n    this._overlayContentElement?.scrollTo(0, 0);\n    this.state = 'closed';\n    this.hidePopover?.();\n    this.inertController.deactivate();\n    if (!this.skipFocusRestoration) {\n      // Manually focus last focused element\n      this.lastFocusedElement?.focus();\n    }\n    this.openOverlayController?.abort();\n    this.focusTrapController.enabled = false;\n    this.removeInstanceFromGlobalCollection();\n    // Enable scrolling for content below the overlay if no overlay is open\n    if (!overlayRefs.length) {\n      this.scrollHandler.enableScroll();\n    }\n    this.escapableOverlayController.disconnect();\n    this.dispatchCloseEvent();\n  }\n\n  protected override dispatchBeforeCloseEvent(): boolean {\n    /** @type {SbbOverlayCloseEvent} Emits whenever the component begins the closing transition. Can be canceled. */\n    return this.dispatchEvent(\n      new SbbOverlayCloseEvent('beforeclose', {\n        cancelable: true,\n        closeAttribute: this.closeAttribute,\n        closeTarget: this.overlayCloseElement,\n        result: this.returnValue,\n      }),\n    );\n  }\n\n  protected override dispatchCloseEvent(): boolean {\n    /** @type {SbbOverlayCloseEvent} Emits whenever the component is closed. */\n    return this.dispatchEvent(\n      new SbbOverlayCloseEvent('close', {\n        closeAttribute: this.closeAttribute,\n        closeTarget: this.overlayCloseElement,\n        result: this.returnValue,\n      }),\n    );\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-overlay__container\" @animationend=${this.onOverlayAnimationEnd}>\n        <div class=\"sbb-overlay\">\n          <div\n            @click=${(event: Event) => this.closeOnSbbOverlayCloseClick(event)}\n            class=\"sbb-overlay__wrapper\"\n          >\n            <div class=\"sbb-overlay__header\">\n              <sbb-secondary-button\n                class=\"sbb-overlay__close\"\n                aria-label=\"${this.accessibilityCloseLabel ||\n                i18nCloseDialog[this.language.current]}\"\n                ?negative=${this.negative}\n                size=\"m\"\n                icon-name=\"cross-small\"\n                sbb-overlay-close\n              ></sbb-secondary-button>\n            </div>\n            <div\n              class=\"sbb-overlay__content ${this.negative\n                ? 'sbb-scrollbar-negative'\n                : 'sbb-scrollbar'}\"\n              ${ref((el?: Element) => (this._overlayContentElement = el as HTMLDivElement))}\n              @scroll=${(e: Event) => forwardEvent(e, document)}\n            >\n              <sbb-container\n                class=\"sbb-overlay__content-container\"\n                ?expanded=${this.expanded}\n                color=\"transparent\"\n              >\n                <slot></slot>\n              </sbb-container>\n            </div>\n          </div>\n        </div>\n      </div>\n      <span class=\"sbb-screen-reader-only\" aria-live=\"polite\"></span>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-overlay': SbbOverlayElement;\n  }\n}\n"],"mappings":"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"}

package/development/overlay.js

@@ -1,5 +1,5 @@
 import { SbbOverlayBaseElement, SbbOverlayCloseEvent, assignOverlayResult, overlayRefs } from "./overlay/overlay-base-element.js";
-import { t as SbbOverlayElement } from "./overlay.component-rFmitc_r.js";
+import { t as SbbOverlayElement } from "./overlay.component-YSCuGeme.js";
 import "./overlay.pure.js";
 //#region src/elements/overlay.ts
 /** @entrypoint */

package/development/overlay.pure.js

@@ -1,3 +1,3 @@
 import { SbbOverlayBaseElement, SbbOverlayCloseEvent, assignOverlayResult, overlayRefs } from "./overlay/overlay-base-element.js";
-import { t as SbbOverlayElement } from "./overlay.component-rFmitc_r.js";
+import { t as SbbOverlayElement } from "./overlay.component-YSCuGeme.js";
 export { SbbOverlayBaseElement, SbbOverlayCloseEvent, SbbOverlayElement, assignOverlayResult, overlayRefs };

package/development/paginator/common/paginator-common.d.ts

@@ -1,10 +1,15 @@
 import { TemplateResult } from 'lit';
 import { AbstractConstructor, SbbElement, SbbElementConstructor, SbbLanguageController } from '../../core.ts';
-export interface SbbPaginatorPageEventDetails {
-    length: number;
-    pageSize: number;
-    pageIndex: number;
-    previousPageIndex: number;
+export declare class SbbPaginatorPageEvent extends Event {
+    private readonly _length;
+    private readonly _pageSize;
+    private readonly _pageIndex;
+    private readonly _previousPageIndex;
+    get length(): number;
+    get pageSize(): number;
+    get pageIndex(): number;
+    get previousPageIndex(): number;
+    constructor({ length, pageSize, pageIndex, previousPageIndex, }: Omit<SbbPaginatorPageEvent, keyof Event>);
 }
 declare const SbbPaginatorCommonElementMixinType_base: AbstractConstructor<import('../../core.ts').SbbNegativeMixinType> & AbstractConstructor<import('../../core.ts').SbbDisabledMixinType> & typeof SbbElement;
 export declare abstract class SbbPaginatorCommonElementMixinType extends SbbPaginatorCommonElementMixinType_base {
@@ -32,7 +37,7 @@ export declare abstract class SbbPaginatorCommonElementMixinType extends SbbPagi
 export declare const SbbPaginatorCommonElementMixin: <T extends AbstractConstructor<SbbElement> & SbbElementConstructor>(superClass: T) => AbstractConstructor<SbbPaginatorCommonElementMixinType> & T;
 declare global {
     interface HTMLElementEventMap {
-        page: CustomEvent<SbbPaginatorPageEventDetails>;
+        page: SbbPaginatorPageEvent;
     }
 }
 export {};

package/development/paginator/common/paginator-common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paginator-common.d.ts","sourceRoot":"","sources":["../../../../../src/elements/paginator/common/paginator-common.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAIb,OAAO,EACL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAG1B,qBAAqB,EAGtB,MAAM,eAAe,CAAC;AAKvB,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;;AAED,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,kCAAmC,SAAQ,uCAExE;IACC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAgB,aAAa,EAAE,OAAO,GAAG,KAAK,CAAC;IAC/C,SAAgB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;IACvC,SAAgB,sBAAsB,EAAE,MAAM,CAAC;IAC/C,SAAgB,8BAA8B,EAAE,MAAM,CAAC;IACvD,SAAgB,0BAA0B,EAAE,MAAM,CAAC;IAC5C,QAAQ,IAAI,IAAI;IAChB,YAAY,IAAI,IAAI;IACpB,SAAS,IAAI,IAAI;IACjB,QAAQ,IAAI,IAAI;IAChB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAC/B,eAAe,IAAI,OAAO;IAC1B,WAAW,IAAI,OAAO;IACtB,aAAa,IAAI,MAAM;IAC9B,SAAS,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAC1C,SAAS,CAAC,aAAa,CAAC,iBAAiB,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAC5E,SAAS,CAAC,qBAAqB,IAAI,cAAc;IACjD,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,cAAc;CACrD;AAGD,eAAO,MAAM,8BAA8B,GACzC,CAAC,SAAS,mBAAmB,CAAC,UAAU,CAAC,GAAG,qBAAqB,EAEjE,YAAY,CAAC,KACZ,mBAAmB,CAAC,kCAAkC,CAAC,GAAG,CA2P5D,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,mBAAmB;QAC3B,IAAI,EAAE,WAAW,CAAC,4BAA4B,CAAC,CAAC;KACjD;CACF"}
+{"version":3,"file":"paginator-common.d.ts","sourceRoot":"","sources":["../../../../../src/elements/paginator/common/paginator-common.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAIb,OAAO,EACL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAG1B,qBAAqB,EAGtB,MAAM,eAAe,CAAC;AAKvB,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAE5C,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,iBAAiB,IAAI,MAAM,CAErC;gBAEkB,EACjB,MAAM,EACN,QAAQ,EACR,SAAS,EACT,iBAAiB,GAClB,EAAE,IAAI,CAAC,qBAAqB,EAAE,MAAM,KAAK,CAAC;CAO5C;;AAED,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,kCAAmC,SAAQ,uCAExE;IACC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAgB,aAAa,EAAE,OAAO,GAAG,KAAK,CAAC;IAC/C,SAAgB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;IACvC,SAAgB,sBAAsB,EAAE,MAAM,CAAC;IAC/C,SAAgB,8BAA8B,EAAE,MAAM,CAAC;IACvD,SAAgB,0BAA0B,EAAE,MAAM,CAAC;IAC5C,QAAQ,IAAI,IAAI;IAChB,YAAY,IAAI,IAAI;IACpB,SAAS,IAAI,IAAI;IACjB,QAAQ,IAAI,IAAI;IAChB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAC/B,eAAe,IAAI,OAAO;IAC1B,WAAW,IAAI,OAAO;IACtB,aAAa,IAAI,MAAM;IAC9B,SAAS,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAC1C,SAAS,CAAC,aAAa,CAAC,iBAAiB,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAC5E,SAAS,CAAC,qBAAqB,IAAI,cAAc;IACjD,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,cAAc;CACrD;AAGD,eAAO,MAAM,8BAA8B,GACzC,CAAC,SAAS,mBAAmB,CAAC,UAAU,CAAC,GAAG,qBAAqB,EAEjE,YAAY,CAAC,KACZ,mBAAmB,CAAC,kCAAkC,CAAC,GAAG,CAyP5D,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,mBAAmB;QAC3B,IAAI,EAAE,qBAAqB,CAAC;KAC7B;CACF"}

package/development/paginator/common/paginator-common.js

@@ -1,2 +1,2 @@
-import { t as SbbPaginatorCommonElementMixin } from "../../paginator-common-BCeNUko_.js";
-export { SbbPaginatorCommonElementMixin };
+import { n as SbbPaginatorPageEvent, t as SbbPaginatorCommonElementMixin } from "../../paginator-common-B7iba0wQ.js";
+export { SbbPaginatorCommonElementMixin, SbbPaginatorPageEvent };

package/development/paginator-common-B7iba0wQ.js

@@ -0,0 +1,432 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, nothing, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbDisabledMixin, SbbLanguageController, SbbNegativeMixin, forceType, i18nNextPage, i18nPage, i18nPaginatorSelected, i18nPreviousPage, sbbInputModalityDetector, screenReaderOnlyStyles } from "./core.js";
+import { SbbMiniButtonElement, SbbMiniButtonGroupElement } from "./button.pure.js";
+import { SbbDividerElement } from "./divider.pure.js";
+//#region src/elements/paginator/common/paginator-common.scss?inline
+var paginator_common_default = ":host([size=s]) {\n  --sbb-paginator-height: var(--sbb-size-element-xs);\n}\n\n:host([size=m]) {\n  --sbb-paginator-height: var(--sbb-size-element-m);\n}\n\n:host([negative]) {\n  --sbb-paginator-color: var(--sbb-color-5);\n}";
+//#endregion
+//#region src/elements/paginator/common/paginator-common.ts
+var SbbPaginatorPageEvent = class extends Event {
+	get length() {
+		return this._length;
+	}
+	get pageSize() {
+		return this._pageSize;
+	}
+	get pageIndex() {
+		return this._pageIndex;
+	}
+	get previousPageIndex() {
+		return this._previousPageIndex;
+	}
+	constructor({ length, pageSize, pageIndex, previousPageIndex }) {
+		super("page", {
+			bubbles: true,
+			composed: true
+		});
+		this._length = length;
+		this._pageSize = pageSize;
+		this._pageIndex = pageIndex;
+		this._previousPageIndex = previousPageIndex;
+	}
+};
+var SbbPaginatorCommonElementMixin = (superClass) => {
+	return (() => {
+		let _classSuper = SbbNegativeMixin(SbbDisabledMixin(superClass));
+		let _length_decorators;
+		let _length_initializers = [];
+		let _length_extraInitializers = [];
+		let _pageSize_decorators;
+		let _pageSize_initializers = [];
+		let _pageSize_extraInitializers = [];
+		let _pageIndex_decorators;
+		let _pageIndex_initializers = [];
+		let _pageIndex_extraInitializers = [];
+		let _pagerPosition_decorators;
+		let _pagerPosition_initializers = [];
+		let _pagerPosition_extraInitializers = [];
+		let _size_decorators;
+		let _size_initializers = [];
+		let _size_extraInitializers = [];
+		let _accessibilityPageLabel_decorators;
+		let _accessibilityPageLabel_initializers = [];
+		let _accessibilityPageLabel_extraInitializers = [];
+		let _accessibilityPreviousPageLabel_decorators;
+		let _accessibilityPreviousPageLabel_initializers = [];
+		let _accessibilityPreviousPageLabel_extraInitializers = [];
+		let _accessibilityNextPageLabel_decorators;
+		let _accessibilityNextPageLabel_initializers = [];
+		let _accessibilityNextPageLabel_extraInitializers = [];
+		return class SbbPaginatorCommonElement extends _classSuper {
+			constructor() {
+				super(...arguments);
+				this.#length_accessor_storage = __runInitializers(this, _length_initializers, 0);
+				this.#pageSize_accessor_storage = (__runInitializers(this, _length_extraInitializers), __runInitializers(this, _pageSize_initializers, 10));
+				this.#pageIndex_accessor_storage = (__runInitializers(this, _pageSize_extraInitializers), __runInitializers(this, _pageIndex_initializers, 0));
+				this.#pagerPosition_accessor_storage = (__runInitializers(this, _pageIndex_extraInitializers), __runInitializers(this, _pagerPosition_initializers, "start"));
+				this.#size_accessor_storage = (__runInitializers(this, _pagerPosition_extraInitializers), __runInitializers(this, _size_initializers, null));
+				this.#accessibilityPageLabel_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _accessibilityPageLabel_initializers, ""));
+				this.#accessibilityPreviousPageLabel_accessor_storage = (__runInitializers(this, _accessibilityPageLabel_extraInitializers), __runInitializers(this, _accessibilityPreviousPageLabel_initializers, ""));
+				this.#accessibilityNextPageLabel_accessor_storage = (__runInitializers(this, _accessibilityPreviousPageLabel_extraInitializers), __runInitializers(this, _accessibilityNextPageLabel_initializers, ""));
+				this.language = (__runInitializers(this, _accessibilityNextPageLabel_extraInitializers), new SbbLanguageController(this));
+			}
+			static {
+				const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+				_length_decorators = [forceType(), property({ type: Number })];
+				_pageSize_decorators = [forceType(), property({
+					attribute: "page-size",
+					type: Number
+				})];
+				_pageIndex_decorators = [forceType(), property({
+					attribute: "page-index",
+					type: Number
+				})];
+				_pagerPosition_decorators = [property({
+					attribute: "pager-position",
+					reflect: true
+				})];
+				_size_decorators = [property({ reflect: true })];
+				_accessibilityPageLabel_decorators = [forceType(), property({ attribute: "accessibility-page-label" })];
+				_accessibilityPreviousPageLabel_decorators = [forceType(), property({ attribute: "accessibility-previous-page-label" })];
+				_accessibilityNextPageLabel_decorators = [forceType(), property({ attribute: "accessibility-next-page-label" })];
+				__esDecorate(this, null, _length_decorators, {
+					kind: "accessor",
+					name: "length",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "length" in obj,
+						get: (obj) => obj.length,
+						set: (obj, value) => {
+							obj.length = value;
+						}
+					},
+					metadata: _metadata
+				}, _length_initializers, _length_extraInitializers);
+				__esDecorate(this, null, _pageSize_decorators, {
+					kind: "accessor",
+					name: "pageSize",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "pageSize" in obj,
+						get: (obj) => obj.pageSize,
+						set: (obj, value) => {
+							obj.pageSize = value;
+						}
+					},
+					metadata: _metadata
+				}, _pageSize_initializers, _pageSize_extraInitializers);
+				__esDecorate(this, null, _pageIndex_decorators, {
+					kind: "accessor",
+					name: "pageIndex",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "pageIndex" in obj,
+						get: (obj) => obj.pageIndex,
+						set: (obj, value) => {
+							obj.pageIndex = value;
+						}
+					},
+					metadata: _metadata
+				}, _pageIndex_initializers, _pageIndex_extraInitializers);
+				__esDecorate(this, null, _pagerPosition_decorators, {
+					kind: "accessor",
+					name: "pagerPosition",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "pagerPosition" in obj,
+						get: (obj) => obj.pagerPosition,
+						set: (obj, value) => {
+							obj.pagerPosition = value;
+						}
+					},
+					metadata: _metadata
+				}, _pagerPosition_initializers, _pagerPosition_extraInitializers);
+				__esDecorate(this, null, _size_decorators, {
+					kind: "accessor",
+					name: "size",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "size" in obj,
+						get: (obj) => obj.size,
+						set: (obj, value) => {
+							obj.size = value;
+						}
+					},
+					metadata: _metadata
+				}, _size_initializers, _size_extraInitializers);
+				__esDecorate(this, null, _accessibilityPageLabel_decorators, {
+					kind: "accessor",
+					name: "accessibilityPageLabel",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "accessibilityPageLabel" in obj,
+						get: (obj) => obj.accessibilityPageLabel,
+						set: (obj, value) => {
+							obj.accessibilityPageLabel = value;
+						}
+					},
+					metadata: _metadata
+				}, _accessibilityPageLabel_initializers, _accessibilityPageLabel_extraInitializers);
+				__esDecorate(this, null, _accessibilityPreviousPageLabel_decorators, {
+					kind: "accessor",
+					name: "accessibilityPreviousPageLabel",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "accessibilityPreviousPageLabel" in obj,
+						get: (obj) => obj.accessibilityPreviousPageLabel,
+						set: (obj, value) => {
+							obj.accessibilityPreviousPageLabel = value;
+						}
+					},
+					metadata: _metadata
+				}, _accessibilityPreviousPageLabel_initializers, _accessibilityPreviousPageLabel_extraInitializers);
+				__esDecorate(this, null, _accessibilityNextPageLabel_decorators, {
+					kind: "accessor",
+					name: "accessibilityNextPageLabel",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "accessibilityNextPageLabel" in obj,
+						get: (obj) => obj.accessibilityNextPageLabel,
+						set: (obj, value) => {
+							obj.accessibilityNextPageLabel = value;
+						}
+					},
+					metadata: _metadata
+				}, _accessibilityNextPageLabel_initializers, _accessibilityNextPageLabel_extraInitializers);
+				if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+					enumerable: true,
+					configurable: true,
+					writable: true,
+					value: _metadata
+				});
+			}
+			static {
+				this.styles = [screenReaderOnlyStyles, unsafeCSS(paginator_common_default)];
+			}
+			static {
+				this.elementDependencies = [
+					SbbMiniButtonGroupElement,
+					SbbMiniButtonElement,
+					SbbDividerElement
+				];
+			}
+			static {
+				this.role = "group";
+			}
+			#length_accessor_storage;
+			/** Total number of items. */
+			get length() {
+				return this.#length_accessor_storage;
+			}
+			set length(value) {
+				this.#length_accessor_storage = value;
+			}
+			#pageSize_accessor_storage;
+			/** Number of items per page. */
+			get pageSize() {
+				return this.#pageSize_accessor_storage;
+			}
+			set pageSize(value) {
+				this.#pageSize_accessor_storage = value;
+			}
+			#pageIndex_accessor_storage;
+			/** Current page index. */
+			get pageIndex() {
+				return this.#pageIndex_accessor_storage;
+			}
+			set pageIndex(value) {
+				this.#pageIndex_accessor_storage = value;
+			}
+			#pagerPosition_accessor_storage;
+			/** Position of the prev/next buttons. */
+			get pagerPosition() {
+				return this.#pagerPosition_accessor_storage;
+			}
+			set pagerPosition(value) {
+				this.#pagerPosition_accessor_storage = value;
+			}
+			#size_accessor_storage;
+			/**
+			* Size variant, either s (lean theme default) or m (standard theme default).
+			*/
+			get size() {
+				return this.#size_accessor_storage;
+			}
+			set size(value) {
+				this.#size_accessor_storage = value;
+			}
+			#accessibilityPageLabel_accessor_storage;
+			/**
+			* Accessibility label for the page. Defaults to `page`.
+			* Can be set for cases like a carousel, where `slide` or `image` fits better.
+			*/
+			get accessibilityPageLabel() {
+				return this.#accessibilityPageLabel_accessor_storage;
+			}
+			set accessibilityPageLabel(value) {
+				this.#accessibilityPageLabel_accessor_storage = value;
+			}
+			#accessibilityPreviousPageLabel_accessor_storage;
+			/**
+			* Accessibility label for the previous page. Defaults to `previous page`.
+			* Can be set for cases like a carousel, where `slide` or `image` fits better.
+			*/
+			get accessibilityPreviousPageLabel() {
+				return this.#accessibilityPreviousPageLabel_accessor_storage;
+			}
+			set accessibilityPreviousPageLabel(value) {
+				this.#accessibilityPreviousPageLabel_accessor_storage = value;
+			}
+			#accessibilityNextPageLabel_accessor_storage;
+			/**
+			* Accessibility label for the next page. Defaults to `next page`.
+			* Can be set for cases like a carousel, where `slide` or `image` fits better.
+			*/
+			get accessibilityNextPageLabel() {
+				return this.#accessibilityNextPageLabel_accessor_storage;
+			}
+			set accessibilityNextPageLabel(value) {
+				this.#accessibilityNextPageLabel_accessor_storage = value;
+			}
+			willUpdate(changedProperties) {
+				super.willUpdate(changedProperties);
+				let prevPageIndex = null;
+				if (changedProperties.has("length") && this.length !== changedProperties.get("length")) {
+					this.length = isNaN(this.length) || this.length < 0 ? 0 : this.length;
+					/**
+					* If the pageIndex changes, it's added in the changedProperties map
+					* and handled in the pageIndex logic below, emitting the page event.
+					* If the pageIndex doesn't change there's no need to emit.
+					*/
+					this.pageIndex = this._coercePageIndexInRange(this.pageIndex);
+				}
+				if (changedProperties.has("pageSize") && this.pageSize !== changedProperties.get("pageSize")) {
+					const previousPageSize = changedProperties.get("pageSize");
+					this.pageSize = isNaN(this.pageSize) || this.pageSize < 0 ? 0 : this.pageSize;
+					if (previousPageSize && !changedProperties.has("pageIndex")) this.pageIndex = Math.floor(this.pageIndex * previousPageSize / this.pageSize) || 0;
+					/**
+					* If the pageIndex changes, it's added in the changedProperties map,
+					* and this line is useless, since the correct value will be calculated in the logic below;
+					* if the pageIndex doesn't change (e.g. change pageSize at pageIndex 0), the prevPageIndex and pageIndex are the same.
+					* In both case the page event must be triggered to allow consumers to retrieve the correct data.
+					*/
+					prevPageIndex = this.pageIndex;
+				}
+				if (changedProperties.has("pageIndex") && this.pageIndex !== changedProperties.get("pageIndex")) {
+					this.pageIndex = this._coercePageIndexInRange(this.pageIndex);
+					prevPageIndex = changedProperties.get("pageIndex");
+				}
+				if (prevPageIndex !== null) this._emitPageEvent(prevPageIndex);
+			}
+			updated(changedProperties) {
+				super.updated(changedProperties);
+				this.shadowRoot.querySelector(".sbb-screen-reader-only#status").textContent = this._currentPageLabel();
+			}
+			/** Evaluate `pageIndex` by excluding edge cases. */
+			_coercePageIndexInRange(pageIndex) {
+				return Math.max(Math.min(Math.max(isNaN(pageIndex) ? 0 : pageIndex, 0), this.numberOfPages() - 1), 0);
+			}
+			_currentPageLabel() {
+				return `${this.accessibilityPageLabel ? this.accessibilityPageLabel : i18nPage[this.language.current]} ${this.pageIndex + 1} ${i18nPaginatorSelected[this.language.current]}.`;
+			}
+			/** Advances to the next page if it exists. */
+			nextPage() {
+				this.pageIndex = this.pageIndex + 1;
+			}
+			/** Move back to the previous page if it exists. */
+			previousPage() {
+				this.pageIndex = this.pageIndex - 1;
+			}
+			/** Move to the first page if not already there. */
+			firstPage() {
+				this.pageIndex = 0;
+			}
+			/** Move to the last page if not already there. */
+			lastPage() {
+				this.pageIndex = this.numberOfPages() - 1;
+			}
+			/** Move to a specific page index. */
+			selectPage(index) {
+				this.pageIndex = index;
+			}
+			/** Whether there is a previous page. */
+			hasPreviousPage() {
+				return this.pageIndex >= 1 && this.pageSize !== 0;
+			}
+			/** Whether there is a next page. */
+			hasNextPage() {
+				const maxPageIndex = this.numberOfPages() - 1;
+				return this.pageIndex < maxPageIndex && this.pageSize !== 0;
+			}
+			/**
+			* Calculates the current number of pages based on the `length` and the `pageSize`;
+			* value must be rounded up (e.g. `length = 21` and `pageSize = 10` means 3 pages).
+			*/
+			numberOfPages() {
+				return this.pageSize ? Math.ceil(this.length / this.pageSize) : 0;
+			}
+			_emitPageEvent(previousPageIndex) {
+				if (this.hasUpdated) {
+					const page = {
+						previousPageIndex,
+						pageIndex: this.pageIndex,
+						length: this.length,
+						pageSize: this.pageSize
+					};
+					/**
+					* @type {SbbPaginatorPageEvent}
+					* The page event is dispatched when the page index, length or page size changes.
+					*/
+					this.dispatchEvent(new SbbPaginatorPageEvent(page));
+				}
+			}
+			renderPrevNextButtons() {
+				return html`
+        <sbb-mini-button-group ?negative=${this.negative} size=${this.size || nothing}>
+          <sbb-mini-button
+            id="sbb-paginator-prev-page"
+            aria-label=${this.accessibilityPreviousPageLabel ? this.accessibilityPreviousPageLabel : i18nPreviousPage[this.language.current]}
+            icon-name="chevron-small-left-small"
+            ?disabled=${this.disabled || !this.hasPreviousPage()}
+            @click=${() => {
+					this.previousPage();
+					if (!this.hasPreviousPage() && sbbInputModalityDetector.mostRecentModality === "keyboard") this.shadowRoot?.getElementById("sbb-paginator-next-page").focus();
+				}}
+          ></sbb-mini-button>
+          <sbb-divider orientation="vertical"></sbb-divider>
+          <sbb-mini-button
+            id="sbb-paginator-next-page"
+            aria-label=${this.accessibilityNextPageLabel ? this.accessibilityNextPageLabel : i18nNextPage[this.language.current]}
+            icon-name="chevron-small-right-small"
+            ?disabled=${this.disabled || !this.hasNextPage()}
+            @click=${() => {
+					this.nextPage();
+					if (!this.hasNextPage() && sbbInputModalityDetector.mostRecentModality === "keyboard") this.shadowRoot?.getElementById("sbb-paginator-prev-page").focus();
+				}}
+          ></sbb-mini-button>
+        </sbb-mini-button-group>
+      `;
+			}
+			render() {
+				return html`
+        ${this.renderPaginator()}
+        <span class="sbb-screen-reader-only" id="status" role="status"></span>
+      `;
+			}
+		};
+	})();
+};
+//#endregion
+export { SbbPaginatorPageEvent as n, SbbPaginatorCommonElementMixin as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"paginator-common-B7iba0wQ.js","names":[],"sources":["../../../src/elements/paginator/common/paginator-common.scss?inline","../../../src/elements/paginator/common/paginator-common.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host([size='s']) {\n  --sbb-paginator-height: var(--sbb-size-element-xs);\n}\n\n:host([size='m']) {\n  --sbb-paginator-height: var(--sbb-size-element-m);\n}\n\n:host([negative]) {\n  --sbb-paginator-color: var(--sbb-color-5);\n}\n","import {\n  type CSSResultGroup,\n  html,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbMiniButtonElement, SbbMiniButtonGroupElement } from '../../button.pure.ts';\nimport {\n  type AbstractConstructor,\n  forceType,\n  i18nNextPage,\n  i18nPage,\n  i18nPaginatorSelected,\n  i18nPreviousPage,\n  SbbDisabledMixin,\n  type SbbElement,\n  type SbbElementConstructor,\n  type SbbElementType,\n  sbbInputModalityDetector,\n  SbbLanguageController,\n  SbbNegativeMixin,\n  screenReaderOnlyStyles,\n} from '../../core.ts';\nimport { SbbDividerElement } from '../../divider.pure.ts';\n\nimport style from './paginator-common.scss?inline';\n\nexport class SbbPaginatorPageEvent extends Event {\n  private readonly _length: number;\n  private readonly _pageSize: number;\n  private readonly _pageIndex: number;\n  private readonly _previousPageIndex: number;\n\n  public get length(): number {\n    return this._length;\n  }\n\n  public get pageSize(): number {\n    return this._pageSize;\n  }\n\n  public get pageIndex(): number {\n    return this._pageIndex;\n  }\n\n  public get previousPageIndex(): number {\n    return this._previousPageIndex;\n  }\n\n  public constructor({\n    length,\n    pageSize,\n    pageIndex,\n    previousPageIndex,\n  }: Omit<SbbPaginatorPageEvent, keyof Event>) {\n    super('page', { bubbles: true, composed: true });\n    this._length = length;\n    this._pageSize = pageSize;\n    this._pageIndex = pageIndex;\n    this._previousPageIndex = previousPageIndex;\n  }\n}\n\nexport declare abstract class SbbPaginatorCommonElementMixinType extends SbbNegativeMixin(\n  SbbDisabledMixin(SbbElement),\n) {\n  public accessor length: number;\n  public accessor pageSize: number;\n  public accessor pageIndex: number;\n  public accessor pagerPosition: 'start' | 'end';\n  public accessor size: 's' | 'm' | null;\n  public accessor accessibilityPageLabel: string;\n  public accessor accessibilityPreviousPageLabel: string;\n  public accessor accessibilityNextPageLabel: string;\n  public nextPage(): void;\n  public previousPage(): void;\n  public firstPage(): void;\n  public lastPage(): void;\n  public selectPage(index: number): void;\n  public hasPreviousPage(): boolean;\n  public hasNextPage(): boolean;\n  public numberOfPages(): number;\n  protected language: SbbLanguageController;\n  protected emitPageEvent(previousPageIndex: number, pageIndex?: number): void;\n  protected renderPrevNextButtons(): TemplateResult;\n  protected abstract renderPaginator(): TemplateResult;\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbPaginatorCommonElementMixin = <\n  T extends AbstractConstructor<SbbElement> & SbbElementConstructor,\n>(\n  superClass: T,\n): AbstractConstructor<SbbPaginatorCommonElementMixinType> & T => {\n  abstract class SbbPaginatorCommonElement\n    extends SbbNegativeMixin(SbbDisabledMixin(superClass))\n    implements Partial<SbbPaginatorCommonElementMixinType>\n  {\n    public static styles: CSSResultGroup = [screenReaderOnlyStyles, unsafeCSS(style)];\n    public static override elementDependencies: SbbElementType[] = [\n      SbbMiniButtonGroupElement,\n      SbbMiniButtonElement,\n      SbbDividerElement,\n    ];\n\n    public static override role = 'group';\n\n    /** Total number of items. */\n    @forceType()\n    @property({ type: Number })\n    public accessor length: number = 0;\n\n    /** Number of items per page. */\n    @forceType()\n    @property({ attribute: 'page-size', type: Number })\n    public accessor pageSize: number = 10;\n\n    /** Current page index. */\n    @forceType()\n    @property({ attribute: 'page-index', type: Number })\n    public accessor pageIndex: number = 0;\n\n    /** Position of the prev/next buttons. */\n    @property({ attribute: 'pager-position', reflect: true }) public accessor pagerPosition:\n      | 'start'\n      | 'end' = 'start';\n\n    /**\n     * Size variant, either s (lean theme default) or m (standard theme default).\n     */\n    @property({ reflect: true }) public accessor size: SbbPaginatorCommonElementMixinType['size'] =\n      null;\n\n    /**\n     * Accessibility label for the page. Defaults to `page`.\n     * Can be set for cases like a carousel, where `slide` or `image` fits better.\n     */\n    @forceType()\n    @property({ attribute: 'accessibility-page-label' })\n    public accessor accessibilityPageLabel: string = '';\n\n    /**\n     * Accessibility label for the previous page. Defaults to `previous page`.\n     * Can be set for cases like a carousel, where `slide` or `image` fits better.\n     */\n    @forceType()\n    @property({ attribute: 'accessibility-previous-page-label' })\n    public accessor accessibilityPreviousPageLabel: string = '';\n\n    /**\n     * Accessibility label for the next page. Defaults to `next page`.\n     * Can be set for cases like a carousel, where `slide` or `image` fits better.\n     */\n    @forceType()\n    @property({ attribute: 'accessibility-next-page-label' })\n    public accessor accessibilityNextPageLabel: string = '';\n\n    protected language = new SbbLanguageController(this);\n    protected abstract renderPaginator(): TemplateResult;\n\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n      let prevPageIndex: number | null = null;\n\n      if (changedProperties.has('length') && this.length !== changedProperties.get('length')) {\n        this.length = isNaN(this.length) || this.length < 0 ? 0 : this.length;\n        /**\n         * If the pageIndex changes, it's added in the changedProperties map\n         * and handled in the pageIndex logic below, emitting the page event.\n         * If the pageIndex doesn't change there's no need to emit.\n         */\n        this.pageIndex = this._coercePageIndexInRange(this.pageIndex);\n      }\n\n      if (\n        changedProperties.has('pageSize') &&\n        this.pageSize !== changedProperties.get('pageSize')\n      ) {\n        const previousPageSize = changedProperties.get('pageSize');\n        this.pageSize = isNaN(this.pageSize) || this.pageSize < 0 ? 0 : this.pageSize;\n        // Current page needs to be updated to reflect the new page size.\n        // Navigate to the page containing the previous page's first item.\n        // If the pageIndex changes in the same update cycle, we shouldn't adjust it.\n        if (previousPageSize && !changedProperties.has('pageIndex')) {\n          this.pageIndex = Math.floor((this.pageIndex * previousPageSize) / this.pageSize) || 0;\n        }\n        /**\n         * If the pageIndex changes, it's added in the changedProperties map,\n         * and this line is useless, since the correct value will be calculated in the logic below;\n         * if the pageIndex doesn't change (e.g. change pageSize at pageIndex 0), the prevPageIndex and pageIndex are the same.\n         * In both case the page event must be triggered to allow consumers to retrieve the correct data.\n         */\n        prevPageIndex = this.pageIndex;\n      }\n\n      if (\n        changedProperties.has('pageIndex') &&\n        this.pageIndex !== changedProperties.get('pageIndex')\n      ) {\n        this.pageIndex = this._coercePageIndexInRange(this.pageIndex);\n        prevPageIndex = changedProperties.get('pageIndex')!;\n      }\n\n      if (prevPageIndex !== null) {\n        this._emitPageEvent(prevPageIndex);\n      }\n    }\n\n    protected override updated(changedProperties: PropertyValues<this>): void {\n      super.updated(changedProperties);\n\n      // To reliably announce page change, we have to set the label in updated() (a tick later than the other changes).\n      this.shadowRoot!.querySelector('.sbb-screen-reader-only#status')!.textContent =\n        this._currentPageLabel();\n    }\n\n    /** Evaluate `pageIndex` by excluding edge cases. */\n    private _coercePageIndexInRange(pageIndex: number): number {\n      return Math.max(\n        Math.min(Math.max(isNaN(pageIndex) ? 0 : pageIndex, 0), this.numberOfPages() - 1),\n        0,\n      );\n    }\n\n    private _currentPageLabel(): string {\n      return `${this.accessibilityPageLabel ? this.accessibilityPageLabel : i18nPage[this.language.current]} ${this.pageIndex + 1} ${i18nPaginatorSelected[this.language.current]}.`;\n    }\n\n    /** Advances to the next page if it exists. */\n    public nextPage(): void {\n      this.pageIndex = this.pageIndex + 1;\n    }\n\n    /** Move back to the previous page if it exists. */\n    public previousPage(): void {\n      this.pageIndex = this.pageIndex - 1;\n    }\n\n    /** Move to the first page if not already there. */\n    public firstPage(): void {\n      this.pageIndex = 0;\n    }\n\n    /** Move to the last page if not already there. */\n    public lastPage(): void {\n      this.pageIndex = this.numberOfPages() - 1;\n    }\n\n    /** Move to a specific page index. */\n    public selectPage(index: number): void {\n      this.pageIndex = index;\n    }\n\n    /** Whether there is a previous page. */\n    public hasPreviousPage(): boolean {\n      return this.pageIndex >= 1 && this.pageSize !== 0;\n    }\n\n    /** Whether there is a next page. */\n    public hasNextPage(): boolean {\n      const maxPageIndex = this.numberOfPages() - 1;\n      return this.pageIndex < maxPageIndex && this.pageSize !== 0;\n    }\n\n    /**\n     * Calculates the current number of pages based on the `length` and the `pageSize`;\n     * value must be rounded up (e.g. `length = 21` and `pageSize = 10` means 3 pages).\n     */\n    public numberOfPages(): number {\n      return this.pageSize ? Math.ceil(this.length / this.pageSize) : 0;\n    }\n\n    private _emitPageEvent(previousPageIndex: number): void {\n      if (this.hasUpdated) {\n        // FIXME: the name of this variable appears as event name in the readme\n        //  due to a bug in the custom-elements-manifest library.\n        //  https://github.com/open-wc/custom-elements-manifest/issues/149\n        const page = {\n          previousPageIndex,\n          pageIndex: this.pageIndex,\n          length: this.length,\n          pageSize: this.pageSize,\n        };\n        /**\n         * @type {SbbPaginatorPageEvent}\n         * The page event is dispatched when the page index, length or page size changes.\n         */\n        this.dispatchEvent(new SbbPaginatorPageEvent(page));\n      }\n    }\n\n    protected renderPrevNextButtons(): TemplateResult {\n      return html`\n        <sbb-mini-button-group ?negative=${this.negative} size=${this.size || nothing}>\n          <sbb-mini-button\n            id=\"sbb-paginator-prev-page\"\n            aria-label=${this.accessibilityPreviousPageLabel\n              ? this.accessibilityPreviousPageLabel\n              : i18nPreviousPage[this.language.current]}\n            icon-name=\"chevron-small-left-small\"\n            ?disabled=${this.disabled || !this.hasPreviousPage()}\n            @click=${() => {\n              this.previousPage();\n              if (\n                !this.hasPreviousPage() &&\n                sbbInputModalityDetector.mostRecentModality === 'keyboard'\n              ) {\n                this.shadowRoot?.getElementById('sbb-paginator-next-page')!.focus();\n              }\n            }}\n          ></sbb-mini-button>\n          <sbb-divider orientation=\"vertical\"></sbb-divider>\n          <sbb-mini-button\n            id=\"sbb-paginator-next-page\"\n            aria-label=${this.accessibilityNextPageLabel\n              ? this.accessibilityNextPageLabel\n              : i18nNextPage[this.language.current]}\n            icon-name=\"chevron-small-right-small\"\n            ?disabled=${this.disabled || !this.hasNextPage()}\n            @click=${() => {\n              this.nextPage();\n              if (\n                !this.hasNextPage() &&\n                sbbInputModalityDetector.mostRecentModality === 'keyboard'\n              ) {\n                this.shadowRoot?.getElementById('sbb-paginator-prev-page')!.focus();\n              }\n            }}\n          ></sbb-mini-button>\n        </sbb-mini-button-group>\n      `;\n    }\n\n    protected override render(): TemplateResult {\n      return html`\n        ${this.renderPaginator()}\n        <span class=\"sbb-screen-reader-only\" id=\"status\" role=\"status\"></span>\n      `;\n    }\n  }\n  return SbbPaginatorCommonElement as unknown as AbstractConstructor<SbbPaginatorCommonElementMixinType> &\n    T;\n};\n\ndeclare global {\n  interface HTMLElementEventMap {\n    page: SbbPaginatorPageEvent;\n  }\n}\n"],"mappings":"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"}