@sbb-esta/lyne-elements 1.11.3 → 1.12.1

package/development/paginator.js

@@ -0,0 +1,519 @@
+import { css, LitElement, html, nothing } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { repeat } from "lit/directives/repeat.js";
+import { sbbInputModalityDetector } from "./core/a11y.js";
+import { SbbLanguageController } from "./core/controllers.js";
+import { hostAttributes } from "./core/decorators.js";
+import { EventEmitter } from "./core/eventing.js";
+import { i18nSelectedPage, i18nPreviousPage, i18nNextPage, i18nItemsPerPage, i18nPage } from "./core/i18n.js";
+import { SbbNegativeMixin } from "./core/mixins.js";
+import "./button/mini-button.js";
+import "./button/mini-button-group.js";
+import "./divider.js";
+import "./form-field.js";
+import "./select.js";
+import "./option.js";
+import "./screen-reader-only.js";
+const style = css`*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  display: block;
+  --sbb-paginator-height: var(--sbb-size-element-m);
+  --sbb-paginator-page-color: var(--sbb-color-metal);
+  --sbb-paginator-page-background-color: transparent;
+  --sbb-paginator-page-border-width: 0;
+  --sbb-paginator-page-border-style: none;
+  --sbb-paginator-page-border-color: none;
+  --sbb-paginator-page-inset: 0;
+  --sbb-paginator-animation-easing: var(--sbb-animation-easing);
+  --sbb-paginator-animation-duration: var(
+    --sbb-disable-animation-zero-time,
+    var(--sbb-animation-duration-2x)
+  );
+  --sbb-paginator-justify-content: start;
+  --sbb-paginator-wrapping-group-wrap: wrap-reverse;
+  --sbb-paginator-wrap: wrap;
+}
+
+:host([size=s]) {
+  --sbb-paginator-height: var(--sbb-size-element-xs);
+}
+
+:host([negative]) {
+  --sbb-paginator-page-color: var(--sbb-color-smoke);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+}
+
+:host([pager-position=end]) {
+  --sbb-paginator-justify-content: end;
+  --sbb-paginator-wrapping-group-wrap: wrap;
+  --sbb-paginator-wrap: wrap-reverse;
+}
+
+.sbb-paginator,
+.sbb-paginator__wrapping-group {
+  display: flex;
+  gap: var(--sbb-spacing-fixed-3x) var(--sbb-spacing-fixed-6x);
+  justify-content: var(--sbb-paginator-justify-content);
+}
+
+.sbb-paginator {
+  flex-wrap: var(--sbb-paginator-wrap);
+  min-height: var(--sbb-paginator-height);
+}
+
+.sbb-paginator__wrapping-group {
+  flex-wrap: var(--sbb-paginator-wrapping-group-wrap);
+}
+
+.sbb-paginator__page-size-options {
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  display: flex;
+  align-items: center;
+  gap: var(--sbb-spacing-fixed-2x);
+  white-space: nowrap;
+  color: var(--sbb-paginator-page-color);
+}
+
+.sbb-paginator__pages {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  font-size: inherit;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: var(--sbb-spacing-fixed-1x);
+  user-select: none;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.sbb-paginator__page--ellipsis,
+.sbb-paginator__page--number {
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  position: relative;
+  color: var(--sbb-paginator-page-color);
+}
+
+.sbb-paginator__page--ellipsis-item,
+.sbb-paginator__page--number-item {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  width: var(--sbb-size-element-xxs);
+  height: var(--sbb-size-element-xxs);
+}
+
+.sbb-paginator__page--number-item {
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  box-sizing: border-box;
+  margin: 0;
+  outline: none;
+  border: none;
+  border-radius: 0;
+  padding: 0;
+  background: none;
+  -webkit-tap-highlight-color: transparent;
+  color: inherit;
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  position: relative;
+  cursor: pointer;
+  outline: none !important;
+  color: var(--sbb-paginator-page-color);
+  transition: color var(--sbb-paginator-animation-duration) var(--sbb-paginator-animation-easing);
+}
+.sbb-paginator__page--number-item::before {
+  content: "";
+  position: absolute;
+  background-color: var(--sbb-paginator-page-background-color);
+  border: var(--sbb-paginator-page-border-width) var(--sbb-paginator-page-border-style) var(--sbb-paginator-page-border-color);
+  border-radius: var(--sbb-border-radius-infinity);
+  inset: var(--sbb-paginator-page-inset);
+  transition-property: background-color, border, inset;
+  transition-duration: var(--sbb-paginator-animation-duration);
+  transition-timing-function: var(--sbb-paginator-animation-easing);
+}
+.sbb-paginator__page--number-item:focus-visible:not([data-focus-origin=mouse], [data-focus-origin=touch])::before {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) solid var(--sbb-focus-outline-width);
+  outline-offset: var(--sbb-border-width-2x);
+}
+.sbb-paginator__page--number-item[data-selected] {
+  font-weight: bold;
+  --sbb-paginator-page-color: var(--sbb-color-charcoal);
+  --sbb-paginator-page-border-width: var(--sbb-border-width-2x);
+  --sbb-paginator-page-border-style: solid;
+  --sbb-paginator-page-border-color: var(--sbb-color-charcoal);
+}
+:host([negative]) .sbb-paginator__page--number-item[data-selected] {
+  --sbb-paginator-page-color: var(--sbb-color-milk);
+  --sbb-paginator-page-border-width: var(--sbb-border-width-2x);
+  --sbb-paginator-page-border-style: solid;
+  --sbb-paginator-page-border-color: var(--sbb-color-white);
+}
+@media (forced-colors: active) {
+  .sbb-paginator__page--number-item[data-selected] {
+    --sbb-paginator-page-border-color: Highlight !important;
+  }
+}
+@media (any-hover: hover) {
+  .sbb-paginator__page--number-item:hover {
+    --sbb-paginator-page-background-color: var(--sbb-color-milk);
+    --sbb-paginator-page-inset: calc(var(--sbb-border-width-2x) * -1);
+    --sbb-paginator-translate-y-content-hover: -0.0625rem;
+  }
+  :host([negative]) .sbb-paginator__page--number-item:hover {
+    --sbb-paginator-page-background-color: var(--sbb-color-charcoal);
+  }
+}
+@media (any-hover: hover) and (forced-colors: active) {
+  .sbb-paginator__page--number-item:hover {
+    --sbb-paginator-page-background-color: Highlight !important;
+  }
+}
+.sbb-paginator__page--number-item:active {
+  --sbb-paginator-page-color: var(--sbb-color-charcoal);
+  --sbb-paginator-page-background-color: var(--sbb-color-cloud);
+  --sbb-paginator-page-inset: 0;
+  --sbb-paginator-translate-y-content-hover: 0;
+}
+:host([negative]) .sbb-paginator__page--number-item:active {
+  --sbb-paginator-page-color: var(--sbb-color-milk);
+  --sbb-paginator-page-background-color: var(--sbb-color-iron);
+}
+@media (forced-colors: active) {
+  .sbb-paginator__page--number-item:active {
+    --sbb-paginator-page-background-color: Highlight !important;
+  }
+}
+
+.sbb-paginator__page--number-item-label {
+  transition: transform var(--sbb-paginator-animation-duration) var(--sbb-paginator-animation-easing);
+  transform: translateY(var(--sbb-paginator-translate-y-content-hover, 0rem));
+}
+
+.sbb-screen-reader-only {
+  border: 0;
+  clip: rect(0 0 0 0);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+  width: 1px;
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+const MAX_PAGE_NUMBERS_DISPLAYED = 3;
+let nextId = 0;
+let SbbPaginatorElement = class extends SbbNegativeMixin(LitElement) {
+  constructor() {
+    super(...arguments);
+    this._length = 0;
+    this._pageSize = 10;
+    this._pageIndex = 0;
+    this.pagerPosition = "start";
+    this.size = "m";
+    this._page = new EventEmitter(
+      this,
+      SbbPaginatorElement.events.page,
+      { composed: true, bubbles: true }
+    );
+    this._paginatorOptionsLabel = `sbb-paginator-options-label-${++nextId}`;
+    this._language = new SbbLanguageController(this);
+    this._markForFocus = null;
+    this._updateSelectAriaLabelledBy = false;
+  }
+  set length(value) {
+    this._length = isNaN(value) || value < 0 ? 0 : value;
+    this.pageIndex = this.pageIndex;
+  }
+  get length() {
+    return this._length;
+  }
+  set pageSize(value) {
+    const previousPageSize = this.pageSize;
+    this._pageSize = Math.max(value, 0);
+    this.pageIndex = Math.floor(this.pageIndex * previousPageSize / this.pageSize) || 0;
+  }
+  get pageSize() {
+    return this._pageSize;
+  }
+  set pageIndex(value) {
+    this._pageIndex = this._coercePageIndexInRange(value);
+  }
+  get pageIndex() {
+    return this._pageIndex;
+  }
+  set pageSizeOptions(value) {
+    this._pageSizeOptions = value;
+    this._updateSelectAriaLabelledBy = true;
+  }
+  get pageSizeOptions() {
+    return this._pageSizeOptions;
+  }
+  updated(changedProperties) {
+    super.updated(changedProperties);
+    if (this._markForFocus && sbbInputModalityDetector.mostRecentModality === "keyboard") {
+      const focusElement = this._getVisiblePages().find(
+        (e) => this.pageIndex === +e.getAttribute("data-index")
+      );
+      if (focusElement) {
+        focusElement.focus();
+      }
+      this._markForFocus = null;
+    }
+    const select = this.shadowRoot.querySelector("sbb-select");
+    if (select && this._updateSelectAriaLabelledBy) {
+      select.setAttribute("aria-labelledby", this._paginatorOptionsLabel);
+      this._updateSelectAriaLabelledBy = false;
+    }
+    this.shadowRoot.querySelector("sbb-screen-reader-only").textContent = this._currentPageLabel();
+  }
+  /**
+   * 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;
+  }
+  /**
+   * If the `pageSize` changes due to user interaction with the `pageSizeOptions` select,
+   * emit the `page` event and then update the `pageSize` value.
+   */
+  _pageSizeChanged(value) {
+    const previousPageSize = this.pageSize;
+    const previousPageIndex = this.pageIndex;
+    this.pageSize = value;
+    if (previousPageSize !== this.pageSize) {
+      this._emitPageEvent(previousPageIndex);
+    }
+  }
+  /**
+   * If the `pageIndex` changes due to user interaction,
+   * emit the `page` event and then update the `pageIndex` value.
+   */
+  _pageIndexChanged(value) {
+    const previousPageIndex = this.pageIndex;
+    this.pageIndex = value;
+    if (previousPageIndex !== this.pageIndex) {
+      this._emitPageEvent(previousPageIndex);
+    }
+  }
+  _emitPageEvent(previousPageIndex) {
+    this._page.emit({
+      previousPageIndex,
+      pageIndex: this.pageIndex,
+      length: this.length,
+      pageSize: this.pageSize
+    });
+  }
+  /** Returns the displayed page elements. */
+  _getVisiblePages() {
+    return Array.from(this.shadowRoot.querySelectorAll(".sbb-paginator__page--number-item"));
+  }
+  /** Evaluate `pageIndex` by excluding edge cases. */
+  _coercePageIndexInRange(pageIndex) {
+    return Math.max(
+      Math.min(Math.max(isNaN(pageIndex) ? 0 : pageIndex, 0), this._numberOfPages() - 1),
+      0
+    );
+  }
+  /**
+   * Calculate the pages set based on the following rules:
+   *  - the first page must always be visible;
+   *  - the last page must always be visible;
+   *  - if there are more than `MAX_PAGE_NUMBERS_DISPLAYED` other pages, ellipsis button must be used.
+   */
+  _getVisiblePagesIndex() {
+    const totalPages = this._numberOfPages();
+    const currentPageIndex = this.pageIndex;
+    if (totalPages <= MAX_PAGE_NUMBERS_DISPLAYED + 2) {
+      return this._range(totalPages);
+    } else if (currentPageIndex < MAX_PAGE_NUMBERS_DISPLAYED) {
+      return [...this._range(MAX_PAGE_NUMBERS_DISPLAYED + 1), "ellipsis", totalPages - 1];
+    } else if (currentPageIndex >= totalPages - MAX_PAGE_NUMBERS_DISPLAYED) {
+      return [
+        0,
+        "ellipsis",
+        ...this._range(MAX_PAGE_NUMBERS_DISPLAYED + 1, totalPages - 1 - MAX_PAGE_NUMBERS_DISPLAYED)
+      ];
+    } else {
+      return [
+        0,
+        "ellipsis",
+        currentPageIndex - 1,
+        currentPageIndex,
+        currentPageIndex + 1,
+        "ellipsis",
+        totalPages - 1
+      ];
+    }
+  }
+  /** Creates an array of consecutive numbers given the length and the starting value. */
+  _range(length, offset = 0) {
+    return Array.from({ length }, (_, k) => k + offset);
+  }
+  _handleKeyUp(event) {
+    if (event.key !== " " && event.key !== "Enter") {
+      return;
+    }
+    const current = this._getVisiblePages().find((e) => e === event.target);
+    if (current) {
+      this._markForFocus = this.pageIndex;
+    }
+  }
+  _currentPageLabel() {
+    return i18nSelectedPage(this.pageIndex + 1)[this._language.current];
+  }
+  _renderPrevNextButtons() {
+    return html`
+      <sbb-mini-button-group ?negative=${this.negative} size=${this.size === "s" ? "s" : "l"}>
+        <sbb-mini-button
+          id="sbb-paginator-prev-page"
+          aria-label=${i18nPreviousPage[this._language.current]}
+          icon-name="chevron-small-left-small"
+          ?disabled=${this.pageIndex === 0}
+          @click=${() => this._pageIndexChanged(this._pageIndex - 1)}
+        ></sbb-mini-button>
+        <sbb-divider orientation="vertical"></sbb-divider>
+        <sbb-mini-button
+          id="sbb-paginator-next-page"
+          aria-label=${i18nNextPage[this._language.current]}
+          icon-name="chevron-small-right-small"
+          ?disabled=${this.pageIndex === this._numberOfPages() - 1}
+          @click=${() => this._pageIndexChanged(this._pageIndex + 1)}
+        ></sbb-mini-button>
+      </sbb-mini-button-group>
+    `;
+  }
+  _renderItemPerPageTemplate() {
+    var _a;
+    return this.pageSizeOptions && this.pageSizeOptions.length > 0 ? html`
+          <div class="sbb-paginator__page-size-options">
+            <label id=${this._paginatorOptionsLabel}>
+              ${i18nItemsPerPage[this._language.current]}
+            </label>
+            <sbb-form-field
+              borderless
+              width="collapse"
+              ?negative=${this.negative}
+              size=${this.size}
+            >
+              <sbb-select
+                value=${((_a = this.pageSizeOptions) == null ? void 0 : _a.find((e) => e === this.pageSize)) ?? this.pageSizeOptions[0]}
+                @change=${(e) => this._pageSizeChanged(+e.target.value)}
+              >
+                ${repeat(
+      this.pageSizeOptions,
+      (element) => html`<sbb-option value=${element}>${element}</sbb-option>`
+    )}
+              </sbb-select>
+            </sbb-form-field>
+          </div>
+        ` : nothing;
+  }
+  _renderPageNumbers() {
+    return html`
+      <ul class="sbb-paginator__pages">
+        ${repeat(
+      this._getVisiblePagesIndex(),
+      (item) => item === "ellipsis" ? html`
+                  <li class="sbb-paginator__page--ellipsis">
+                    <span class="sbb-paginator__page--ellipsis-item">…</span>
+                  </li>
+                ` : html`
+                  <li class="sbb-paginator__page--number">
+                    <button
+                      ?data-selected=${this.pageIndex === item}
+                      class="sbb-paginator__page--number-item"
+                      data-index=${item}
+                      aria-label="${i18nPage[this._language.current]} ${item + 1}"
+                      aria-current=${this.pageIndex === item ? "true" : nothing}
+                      @click=${() => this._pageIndexChanged(item)}
+                      @keyup=${this._handleKeyUp}
+                    >
+                      <span class="sbb-paginator__page--number-item-label">${item + 1}</span>
+                    </button>
+                  </li>
+                `
+    )}
+      </ul>
+    `;
+  }
+  render() {
+    return html`
+      <div class="sbb-paginator">
+        ${this.pagerPosition === "start" ? html`<span class="sbb-paginator__wrapping-group">
+                  ${this._renderPrevNextButtons()} ${this._renderPageNumbers()}
+                </span>
+                ${this._renderItemPerPageTemplate()}` : html`${this._renderItemPerPageTemplate()}
+                <span class="sbb-paginator__wrapping-group">
+                  ${this._renderPageNumbers()} ${this._renderPrevNextButtons()}
+                </span>`}</span>
+      </div>
+      <sbb-screen-reader-only role='status'></sbb-screen-reader-only>
+    `;
+  }
+};
+SbbPaginatorElement.styles = style;
+SbbPaginatorElement.events = {
+  page: "page"
+};
+__decorateClass([
+  property({ type: Number })
+], SbbPaginatorElement.prototype, "length", 1);
+__decorateClass([
+  property({ attribute: "page-size", type: Number })
+], SbbPaginatorElement.prototype, "pageSize", 1);
+__decorateClass([
+  property({ attribute: "page-index", type: Number })
+], SbbPaginatorElement.prototype, "pageIndex", 1);
+__decorateClass([
+  property({ attribute: "page-size-options", type: Array })
+], SbbPaginatorElement.prototype, "pageSizeOptions", 1);
+__decorateClass([
+  property({ attribute: "pager-position", reflect: true })
+], SbbPaginatorElement.prototype, "pagerPosition", 2);
+__decorateClass([
+  property({ reflect: true })
+], SbbPaginatorElement.prototype, "size", 2);
+SbbPaginatorElement = __decorateClass([
+  customElement("sbb-paginator"),
+  hostAttributes({
+    role: "group"
+  })
+], SbbPaginatorElement);
+export {
+  SbbPaginatorElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"paginator.js","sources":["../../../src/elements/paginator/paginator.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  LitElement,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\nimport { repeat } from 'lit/directives/repeat.js';\n\nimport { sbbInputModalityDetector } from '../core/a11y.js';\nimport { SbbLanguageController } from '../core/controllers.js';\nimport { hostAttributes } from '../core/decorators.js';\nimport { EventEmitter } from '../core/eventing.js';\nimport {\n  i18nItemsPerPage,\n  i18nNextPage,\n  i18nPage,\n  i18nPreviousPage,\n  i18nSelectedPage,\n} from '../core/i18n.js';\nimport { SbbNegativeMixin } from '../core/mixins.js';\nimport type { SbbSelectElement } from '../select.js';\n\nimport style from './paginator.scss?lit&inline';\n\nimport '../button/mini-button.js';\nimport '../button/mini-button-group.js';\nimport '../divider.js';\nimport '../form-field.js';\nimport '../select.js';\nimport '../option.js';\nimport '../screen-reader-only.js';\n\nexport type SbbPaginatorPageEventDetails = {\n  length: number;\n  pageSize: number;\n  pageIndex: number;\n  previousPageIndex: number;\n};\n\nconst MAX_PAGE_NUMBERS_DISPLAYED = 3;\n\nlet nextId = 0;\n\n/**\n * It displays a paginator component.\n *\n * @event {CustomEvent<SbbPaginatorPageEventDetails>} page - Emits when the pageIndex changes.\n */\n@customElement('sbb-paginator')\n@hostAttributes({\n  role: 'group',\n})\nexport class SbbPaginatorElement extends SbbNegativeMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events: Record<string, string> = {\n    page: 'page',\n  } as const;\n\n  /** Total number of items. */\n  @property({ type: Number })\n  public set length(value: number) {\n    this._length = isNaN(value) || value < 0 ? 0 : value;\n    // Call setter of pageIndex to ensure bounds\n    // eslint-disable-next-line no-self-assign\n    this.pageIndex = this.pageIndex;\n  }\n  public get length(): number {\n    return this._length;\n  }\n  private _length: number = 0;\n\n  /** Number of items per page. */\n  @property({ attribute: 'page-size', type: Number })\n  public set pageSize(value: number) {\n    // Current page needs to be updated to reflect the new page size. Navigate to the page\n    // containing the previous page's first item.\n    const previousPageSize = this.pageSize;\n    this._pageSize = Math.max(value, 0);\n    this.pageIndex = Math.floor((this.pageIndex * previousPageSize) / this.pageSize) || 0;\n  }\n  public get pageSize(): number {\n    return this._pageSize;\n  }\n  private _pageSize: number = 10;\n\n  /** Current page index. */\n  @property({ attribute: 'page-index', type: Number })\n  public set pageIndex(value: number) {\n    this._pageIndex = this._coercePageIndexInRange(value);\n  }\n  public get pageIndex(): number {\n    return this._pageIndex;\n  }\n  private _pageIndex: number = 0;\n\n  /** The available `pageSize` choices. */\n  @property({ attribute: 'page-size-options', type: Array })\n  public set pageSizeOptions(value: number[]) {\n    this._pageSizeOptions = value;\n    this._updateSelectAriaLabelledBy = true;\n  }\n  public get pageSizeOptions(): number[] | undefined {\n    return this._pageSizeOptions;\n  }\n  private _pageSizeOptions?: number[];\n\n  /**\n   * Position of the prev/next buttons: if `pageSizeOptions` is set, the sbb-select for the pageSize change\n   * will be positioned oppositely with the page numbers always in the center.\n   */\n  @property({ attribute: 'pager-position', reflect: true }) public pagerPosition: 'start' | 'end' =\n    'start';\n\n  /** Size variant, either m or s. */\n  @property({ reflect: true }) public size: 'm' | 's' = 'm';\n\n  private _page: EventEmitter<SbbPaginatorPageEventDetails> = new EventEmitter(\n    this,\n    SbbPaginatorElement.events.page,\n    { composed: true, bubbles: true },\n  );\n\n  private _paginatorOptionsLabel = `sbb-paginator-options-label-${++nextId}`;\n  private _language = new SbbLanguageController(this);\n  private _markForFocus: number | null = null;\n  private _updateSelectAriaLabelledBy: boolean = false;\n\n  protected override updated(changedProperties: PropertyValues<this>): void {\n    super.updated(changedProperties);\n\n    /** Tab navigation can force a rerender when ellipsis elements need to be displayed; the focus must stay on the correct element. */\n    if (this._markForFocus && sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n      const focusElement = this._getVisiblePages().find(\n        (e) => this.pageIndex === +e.getAttribute('data-index')!,\n      );\n      if (focusElement) {\n        (focusElement as HTMLElement).focus();\n      }\n      // Reset mark for focus\n      this._markForFocus = null;\n    }\n\n    /**\n     * TODO: Accessibility fix required to correctly read the label;\n     * can be possibly removed after the merge of https://github.com/sbb-design-systems/lyne-components/issues/3062\n     */\n    const select = this.shadowRoot!.querySelector('sbb-select');\n    if (select && this._updateSelectAriaLabelledBy) {\n      select.setAttribute('aria-labelledby', this._paginatorOptionsLabel);\n      this._updateSelectAriaLabelledBy = false;\n    }\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')!.textContent =\n      this._currentPageLabel();\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  private _numberOfPages(): number {\n    return this.pageSize ? Math.ceil(this.length / this.pageSize) : 0;\n  }\n\n  /**\n   * If the `pageSize` changes due to user interaction with the `pageSizeOptions` select,\n   * emit the `page` event and then update the `pageSize` value.\n   */\n  private _pageSizeChanged(value: number): void {\n    const previousPageSize = this.pageSize;\n    const previousPageIndex = this.pageIndex;\n    this.pageSize = value;\n\n    if (previousPageSize !== this.pageSize) {\n      this._emitPageEvent(previousPageIndex);\n    }\n  }\n\n  /**\n   * If the `pageIndex` changes due to user interaction,\n   * emit the `page` event and then update the `pageIndex` value.\n   */\n  private _pageIndexChanged(value: number): void {\n    const previousPageIndex = this.pageIndex;\n    this.pageIndex = value;\n\n    if (previousPageIndex !== this.pageIndex) {\n      this._emitPageEvent(previousPageIndex);\n    }\n  }\n\n  private _emitPageEvent(previousPageIndex: number): void {\n    this._page.emit({\n      previousPageIndex,\n      pageIndex: this.pageIndex,\n      length: this.length,\n      pageSize: this.pageSize,\n    });\n  }\n\n  /** Returns the displayed page elements. */\n  private _getVisiblePages(): Element[] {\n    return Array.from(this.shadowRoot!.querySelectorAll('.sbb-paginator__page--number-item'));\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  /**\n   * Calculate the pages set based on the following rules:\n   *  - the first page must always be visible;\n   *  - the last page must always be visible;\n   *  - if there are more than `MAX_PAGE_NUMBERS_DISPLAYED` other pages, ellipsis button must be used.\n   */\n  private _getVisiblePagesIndex(): (number | 'ellipsis')[] {\n    const totalPages: number = this._numberOfPages();\n    const currentPageIndex: number = this.pageIndex;\n\n    if (totalPages <= MAX_PAGE_NUMBERS_DISPLAYED + 2) {\n      return this._range(totalPages);\n    } else if (currentPageIndex < MAX_PAGE_NUMBERS_DISPLAYED) {\n      return [...this._range(MAX_PAGE_NUMBERS_DISPLAYED + 1), 'ellipsis', totalPages - 1];\n    } else if (currentPageIndex >= totalPages - MAX_PAGE_NUMBERS_DISPLAYED) {\n      return [\n        0,\n        'ellipsis',\n        ...this._range(MAX_PAGE_NUMBERS_DISPLAYED + 1, totalPages - 1 - MAX_PAGE_NUMBERS_DISPLAYED),\n      ];\n    } else {\n      return [\n        0,\n        'ellipsis',\n        currentPageIndex - 1,\n        currentPageIndex,\n        currentPageIndex + 1,\n        'ellipsis',\n        totalPages - 1,\n      ];\n    }\n  }\n\n  /** Creates an array of consecutive numbers given the length and the starting value. */\n  private _range(length: number, offset: number = 0): number[] {\n    return Array.from({ length }, (_, k) => k + offset);\n  }\n\n  private _handleKeyUp(event: KeyboardEvent): void {\n    if (event.key !== ' ' && event.key !== 'Enter') {\n      return;\n    }\n\n    const current = this._getVisiblePages().find((e: Element) => e === event.target);\n    if (current) {\n      this._markForFocus = this.pageIndex;\n    }\n  }\n\n  private _currentPageLabel(): string {\n    return i18nSelectedPage(this.pageIndex + 1)[this._language.current];\n  }\n\n  private _renderPrevNextButtons(): TemplateResult {\n    return html`\n      <sbb-mini-button-group ?negative=${this.negative} size=${this.size === 's' ? 's' : 'l'}>\n        <sbb-mini-button\n          id=\"sbb-paginator-prev-page\"\n          aria-label=${i18nPreviousPage[this._language.current]}\n          icon-name=\"chevron-small-left-small\"\n          ?disabled=${this.pageIndex === 0}\n          @click=${() => this._pageIndexChanged(this._pageIndex - 1)}\n        ></sbb-mini-button>\n        <sbb-divider orientation=\"vertical\"></sbb-divider>\n        <sbb-mini-button\n          id=\"sbb-paginator-next-page\"\n          aria-label=${i18nNextPage[this._language.current]}\n          icon-name=\"chevron-small-right-small\"\n          ?disabled=${this.pageIndex === this._numberOfPages() - 1}\n          @click=${() => this._pageIndexChanged(this._pageIndex + 1)}\n        ></sbb-mini-button>\n      </sbb-mini-button-group>\n    `;\n  }\n\n  private _renderItemPerPageTemplate(): TemplateResult | typeof nothing {\n    return this.pageSizeOptions && this.pageSizeOptions.length > 0\n      ? html`\n          <div class=\"sbb-paginator__page-size-options\">\n            <label id=${this._paginatorOptionsLabel}>\n              ${i18nItemsPerPage[this._language.current]}\n            </label>\n            <sbb-form-field\n              borderless\n              width=\"collapse\"\n              ?negative=${this.negative}\n              size=${this.size}\n            >\n              <sbb-select\n                value=${this.pageSizeOptions?.find((e) => e === this.pageSize) ??\n                this.pageSizeOptions![0]}\n                @change=${(e: CustomEvent) =>\n                  this._pageSizeChanged(+((e.target as SbbSelectElement).value as string))}\n              >\n                ${repeat(\n                  this.pageSizeOptions!,\n                  (element) => html`<sbb-option value=${element}>${element}</sbb-option>`,\n                )}\n              </sbb-select>\n            </sbb-form-field>\n          </div>\n        `\n      : nothing;\n  }\n\n  private _renderPageNumbers(): TemplateResult {\n    return html`\n      <ul class=\"sbb-paginator__pages\">\n        ${repeat(\n          this._getVisiblePagesIndex(),\n          (item: number | 'ellipsis'): TemplateResult =>\n            item === 'ellipsis'\n              ? html`\n                  <li class=\"sbb-paginator__page--ellipsis\">\n                    <span class=\"sbb-paginator__page--ellipsis-item\">…</span>\n                  </li>\n                `\n              : html`\n                  <li class=\"sbb-paginator__page--number\">\n                    <button\n                      ?data-selected=${this.pageIndex === item}\n                      class=\"sbb-paginator__page--number-item\"\n                      data-index=${item}\n                      aria-label=\"${i18nPage[this._language.current]} ${item + 1}\"\n                      aria-current=${this.pageIndex === item ? 'true' : nothing}\n                      @click=${() => this._pageIndexChanged(item)}\n                      @keyup=${this._handleKeyUp}\n                    >\n                      <span class=\"sbb-paginator__page--number-item-label\">${item + 1}</span>\n                    </button>\n                  </li>\n                `,\n        )}\n      </ul>\n    `;\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-paginator\">\n        ${\n          this.pagerPosition === 'start'\n            ? html`<span class=\"sbb-paginator__wrapping-group\">\n                  ${this._renderPrevNextButtons()} ${this._renderPageNumbers()}\n                </span>\n                ${this._renderItemPerPageTemplate()}`\n            : html`${this._renderItemPerPageTemplate()}\n                <span class=\"sbb-paginator__wrapping-group\">\n                  ${this._renderPageNumbers()} ${this._renderPrevNextButtons()}\n                </span>`\n        }</span>\n      </div>\n      <sbb-screen-reader-only role='status'></sbb-screen-reader-only>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-paginator': SbbPaginatorElement;\n  }\n  interface HTMLElementEventMap {\n    page: CustomEvent<SbbPaginatorPageEventDetails>;\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/popover/popover-trigger.js

@@ -4,14 +4,7 @@ import { SbbButtonBaseElement } from "../core/base-elements.js";
 import { hostContext } from "../core/dom.js";
 import { SbbDisabledTabIndexActionMixin, SbbNegativeMixin } from "../core/mixins.js";
 import { SbbIconNameMixin } from "../icon.js";
-const style = css`/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
-/*
- * SBB table mixin
- * Notes:
- * We cannot use \`border-collapse\` because it is not compatible with the \`border-radius\` property.
- * Therefore, we have to build the grid avoiding double borders.
- */
-*,
+const style = css`*,
 ::before,
 ::after {
   box-sizing: border-box;
@@ -220,4 +213,4 @@ SbbPopoverTriggerElement = __decorateClass([
 export {
   SbbPopoverTriggerElement
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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