@sbb-esta/lyne-elements 1.12.1 → 1.14.0

package/development/paginator/paginator.js

@@ -0,0 +1,449 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __runInitializers, __esDecorate } from "tslib";
+import { css, LitElement, html, nothing } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { repeat } from "lit/directives/repeat.js";
+import { sbbInputModalityDetector } from "../core/a11y.js";
+import { i18nItemsPerPage, i18nPage } from "../core/i18n.js";
+import { SbbPaginatorCommonElementMixin } from "./common.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-cursor: pointer;
+  --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: var(--sbb-paginator-page-cursor);
+  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-color: var(--sbb-color-white);
+}
+@media (forced-colors: active) {
+  .sbb-paginator__page--number-item[data-selected] {
+    --sbb-paginator-page-border-color: Highlight !important;
+  }
+}
+.sbb-paginator__page--number-item:disabled {
+  --sbb-paginator-page-color: var(--sbb-color-smoke);
+  --sbb-paginator-page-border-style: dashed;
+  --sbb-paginator-page-border-color: var(--sbb-color-smoke);
+  --sbb-paginator-page-background-color: var(--sbb-color-milk);
+  --sbb-paginator-page-cursor: default;
+}
+.sbb-paginator__page--number-item:disabled:not([data-selected]) {
+  --sbb-paginator-page-border-width: var(--sbb-border-width-1x);
+}
+:host([negative]) .sbb-paginator__page--number-item:disabled {
+  --sbb-paginator-page-color: var(--sbb-color-aluminium);
+  --sbb-paginator-page-background-color: var(--sbb-color-charcoal);
+}
+@media (forced-colors: active) {
+  .sbb-paginator__page--number-item:disabled {
+    --sbb-paginator-page-border-color: GrayText;
+    --sbb-paginator-page-color: GrayText;
+    --sbb-paginator-page-background-color: Canvas;
+  }
+}
+@media (any-hover: hover) {
+  .sbb-paginator__page--number-item:not(:disabled):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:not(:disabled):hover {
+    --sbb-paginator-page-background-color: var(--sbb-color-charcoal);
+  }
+}
+@media (any-hover: hover) and (forced-colors: active) {
+  .sbb-paginator__page--number-item:not(:disabled):hover {
+    --sbb-paginator-page-background-color: Highlight !important;
+  }
+}
+.sbb-paginator__page--number-item:not(:disabled):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:not(:disabled):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:not(:disabled):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;
+}`;
+const MAX_PAGE_NUMBERS_DISPLAYED = 3;
+let nextId = 0;
+let SbbPaginatorElement = (() => {
+  var _pagerPosition_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-paginator")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbPaginatorCommonElementMixin(LitElement);
+  let _instanceExtraInitializers = [];
+  let _set_pageSizeOptions_decorators;
+  let _pagerPosition_decorators;
+  let _pagerPosition_initializers = [];
+  let _pagerPosition_extraInitializers = [];
+  _a = class extends _classSuper {
+    constructor() {
+      super(...arguments);
+      __privateAdd(this, _pagerPosition_accessor_storage);
+      this._pageSizeOptions = __runInitializers(this, _instanceExtraInitializers);
+      __privateSet(this, _pagerPosition_accessor_storage, __runInitializers(this, _pagerPosition_initializers, "start"));
+      this._paginatorOptionsLabel = (__runInitializers(this, _pagerPosition_extraInitializers), `sbb-paginator-options-label-${++nextId}`);
+      this._markForFocus = null;
+      this._updateSelectAriaLabelledBy = false;
+    }
+    /** The available `pageSize` choices. */
+    set pageSizeOptions(value) {
+      this._pageSizeOptions = value;
+      this._updateSelectAriaLabelledBy = true;
+    }
+    get pageSizeOptions() {
+      return this._pageSizeOptions;
+    }
+    /**
+     * Position of the prev/next buttons: if `pageSizeOptions` is set,
+     * the sbb-select for the pageSize change will be positioned oppositely, with the page numbers always in the center.
+     */
+    get pagerPosition() {
+      return __privateGet(this, _pagerPosition_accessor_storage);
+    }
+    set pagerPosition(value) {
+      __privateSet(this, _pagerPosition_accessor_storage, value);
+    }
+    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;
+      }
+    }
+    /**
+     * 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);
+      }
+    }
+    /** Returns the displayed page elements. */
+    _getVisiblePages() {
+      return Array.from(this.shadowRoot.querySelectorAll(".sbb-paginator__page--number-item"));
+    }
+    /**
+     * 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;
+      }
+    }
+    _renderItemPerPageTemplate() {
+      var _a2;
+      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
+                ?disabled=${this.disabled}
+                value=${((_a2 = this.pageSizeOptions) == null ? void 0 : _a2.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}
+                      ?disabled=${this.disabled}
+                      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>
+    `;
+    }
+    renderPaginator() {
+      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>
+    `;
+    }
+  }, _pagerPosition_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _set_pageSizeOptions_decorators = [property({ attribute: "page-size-options", type: Array })];
+    _pagerPosition_decorators = [property({ attribute: "pager-position", reflect: true })];
+    __esDecorate(_a, null, _set_pageSizeOptions_decorators, { kind: "setter", name: "pageSizeOptions", static: false, private: false, access: { has: (obj) => "pageSizeOptions" in obj, set: (obj, value) => {
+      obj.pageSizeOptions = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, 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(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+    _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = style, _a.events = {
+    page: "page"
+  }, __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+export {
+  SbbPaginatorElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"paginator.js","sources":["../../../../src/elements/paginator/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 { i18nItemsPerPage, i18nPage } from '../../core/i18n.js';\nimport type { SbbSelectElement } from '../../select.js';\nimport { SbbPaginatorCommonElementMixin } from '../common.js';\n\nimport style from './paginator.scss?lit&inline';\n\nimport '../../form-field.js';\nimport '../../select.js';\nimport '../../option.js';\nimport '../../screen-reader-only.js';\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 */\nexport\n@customElement('sbb-paginator')\nclass SbbPaginatorElement extends SbbPaginatorCommonElementMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events: Record<string, string> = {\n    page: 'page',\n  } as const;\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,\n   * the sbb-select for the pageSize change will be positioned oppositely, with the page numbers always in the center.\n   */\n  @property({ attribute: 'pager-position', reflect: true }) public override accessor pagerPosition:\n    | 'start'\n    | 'end' = 'start';\n\n  private _paginatorOptionsLabel = `sbb-paginator-options-label-${++nextId}`;\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\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  /** Returns the displayed page elements. */\n  private _getVisiblePages(): Element[] {\n    return Array.from(this.shadowRoot!.querySelectorAll('.sbb-paginator__page--number-item'));\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 _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                ?disabled=${this.disabled}\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                      ?disabled=${this.disabled}\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 renderPaginator(): 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    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-paginator': SbbPaginatorElement;\n  }\n}\n"],"names":["_a"],"mappings":"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"}

package/development/paginator.d.ts

@@ -1,2 +1,4 @@
+export * from './paginator/common.js';
+export * from './paginator/compact-paginator.js';
 export * from './paginator/paginator.js';
 //# sourceMappingURL=paginator.d.ts.map

package/development/paginator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../../../src/elements/paginator.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../../../src/elements/paginator.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC"}