@sbb-esta/lyne-elements 2.7.1 → 2.9.0

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

@@ -69,7 +69,9 @@ const SbbPaginatorCommonElementMixin = (superClass) => {
       }
       /** Current page index. */
       set pageIndex(value) {
+        const previousPageIndex = this._pageIndex;
         this._pageIndex = this._coercePageIndexInRange(value);
+        this.emitPageEvent(previousPageIndex);
       }
       get pageIndex() {
         return this._pageIndex;
@@ -102,6 +104,35 @@ const SbbPaginatorCommonElementMixin = (superClass) => {
       _currentPageLabel() {
         return i18nSelectedPage(this.pageIndex + 1)[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).
@@ -112,13 +143,10 @@ const SbbPaginatorCommonElementMixin = (superClass) => {
       /**
        * If the `pageIndex` changes due to user interaction,
        * emit the `page` event and then update the `pageIndex` value.
+       * @deprecated Will be removed with next major change.
        */
       pageIndexChanged(value) {
-        const previousPageIndex = this.pageIndex;
         this.pageIndex = value;
-        if (previousPageIndex !== this.pageIndex) {
-          this.emitPageEvent(previousPageIndex);
-        }
       }
       emitPageEvent(previousPageIndex) {
         this._page.emit({
@@ -135,16 +163,16 @@ const SbbPaginatorCommonElementMixin = (superClass) => {
             id="sbb-paginator-prev-page"
             aria-label=${i18nPreviousPage[this.language.current]}
             icon-name="chevron-small-left-small"
-            ?disabled=${this.disabled || this.pageIndex === 0}
-            @click=${() => this.pageIndexChanged(this._pageIndex - 1)}
+            ?disabled=${this.disabled || !this.hasPreviousPage()}
+            @click=${() => this.previousPage()}
           ></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.disabled || this.pageIndex === this.numberOfPages() - 1}
-            @click=${() => this.pageIndexChanged(this._pageIndex + 1)}
+            ?disabled=${this.disabled || !this.hasNextPage()}
+            @click=${() => this.nextPage()}
           ></sbb-mini-button>
         </sbb-mini-button-group>
       `;
@@ -190,4 +218,4 @@ const SbbPaginatorCommonElementMixin = (superClass) => {
 export {
   SbbPaginatorCommonElementMixin
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"paginator-common.js","sources":["../../../../../src/elements/paginator/common/paginator-common.ts"],"sourcesContent":["import { html, type LitElement, type PropertyValues, type TemplateResult } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbLanguageController } from '../../core/controllers.js';\nimport { hostAttributes } from '../../core/decorators.js';\nimport { isLean } from '../../core/dom.js';\nimport { EventEmitter } from '../../core/eventing.js';\nimport { i18nNextPage, i18nPreviousPage, i18nSelectedPage } from '../../core/i18n.js';\nimport type { SbbPaginatorPageEventDetails } from '../../core/interfaces.js';\nimport { type AbstractConstructor, SbbDisabledMixin, SbbNegativeMixin } from '../../core/mixins.js';\n\nimport '../../button/mini-button.js';\nimport '../../button/mini-button-group.js';\nimport '../../divider.js';\n\nexport declare abstract class SbbPaginatorCommonElementMixinType {\n  public accessor negative: boolean;\n  public accessor disabled: boolean;\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: 'm' | 's';\n  protected language: SbbLanguageController;\n  protected numberOfPages(): number;\n  protected pageIndexChanged(value: number): void;\n  protected emitPageEvent(previousPageIndex: 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 = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbPaginatorCommonElementMixinType> & T => {\n  @hostAttributes({\n    role: 'group',\n  })\n  abstract class SbbPaginatorCommonElement\n    extends SbbNegativeMixin(SbbDisabledMixin(superClass))\n    implements Partial<SbbPaginatorCommonElementMixinType>\n  {\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    /** 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 m or s.\n     * @default 'm' / 's' (lean)\n     */\n    @property({ reflect: true }) public accessor size: 'm' | 's' = isLean() ? 's' : 'm';\n\n    private _page: EventEmitter<SbbPaginatorPageEventDetails> = new EventEmitter(\n      this,\n      SbbPaginatorCommonElement.events.page,\n      { composed: true, bubbles: true },\n    );\n    protected language = new SbbLanguageController(this);\n    protected abstract renderPaginator(): string;\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')!.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 i18nSelectedPage(this.pageIndex + 1)[this.language.current];\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    protected numberOfPages(): number {\n      return this.pageSize ? Math.ceil(this.length / this.pageSize) : 0;\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    protected 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    protected 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    protected 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.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.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    protected override render(): TemplateResult {\n      return html`\n        ${this.renderPaginator()}\n        <sbb-screen-reader-only role=\"status\"></sbb-screen-reader-only>\n      `;\n    }\n  }\n  return SbbPaginatorCommonElement as unknown as AbstractConstructor<SbbPaginatorCommonElementMixinType> &\n    T;\n};\n\ndeclare global {\n  interface HTMLElementEventMap {\n    page: CustomEvent<SbbPaginatorPageEventDetails>;\n  }\n}\n"],"names":["SbbPaginatorCommonElement"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"paginator-common.js","sources":["../../../../../src/elements/paginator/common/paginator-common.ts"],"sourcesContent":["import { html, type LitElement, type PropertyValues, type TemplateResult } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbLanguageController } from '../../core/controllers.js';\nimport { hostAttributes } from '../../core/decorators.js';\nimport { isLean } from '../../core/dom.js';\nimport { EventEmitter } from '../../core/eventing.js';\nimport { i18nNextPage, i18nPreviousPage, i18nSelectedPage } from '../../core/i18n.js';\nimport type { SbbPaginatorPageEventDetails } from '../../core/interfaces.js';\nimport { type AbstractConstructor, SbbDisabledMixin, SbbNegativeMixin } from '../../core/mixins.js';\n\nimport '../../button/mini-button.js';\nimport '../../button/mini-button-group.js';\nimport '../../divider.js';\n\nexport declare abstract class SbbPaginatorCommonElementMixinType {\n  public accessor negative: boolean;\n  public accessor disabled: boolean;\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: 'm' | 's';\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  /**\n   * @deprecated Will be removed with next major change.\n   */\n  protected pageIndexChanged(value: number): void;\n  protected emitPageEvent(previousPageIndex: 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 = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbPaginatorCommonElementMixinType> & T => {\n  @hostAttributes({\n    role: 'group',\n  })\n  abstract class SbbPaginatorCommonElement\n    extends SbbNegativeMixin(SbbDisabledMixin(superClass))\n    implements Partial<SbbPaginatorCommonElementMixinType>\n  {\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      const previousPageIndex = this._pageIndex;\n      this._pageIndex = this._coercePageIndexInRange(value);\n      this.emitPageEvent(previousPageIndex);\n    }\n    public get pageIndex(): number {\n      return this._pageIndex;\n    }\n    private _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 m or s.\n     * @default 'm' / 's' (lean)\n     */\n    @property({ reflect: true }) public accessor size: 'm' | 's' = isLean() ? 's' : 'm';\n\n    private _page: EventEmitter<SbbPaginatorPageEventDetails> = new EventEmitter(\n      this,\n      SbbPaginatorCommonElement.events.page,\n      { composed: true, bubbles: true },\n    );\n\n    protected language = new SbbLanguageController(this);\n    protected abstract renderPaginator(): string;\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')!.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 i18nSelectedPage(this.pageIndex + 1)[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    /**\n     * If the `pageIndex` changes due to user interaction,\n     * emit the `page` event and then update the `pageIndex` value.\n     * @deprecated Will be removed with next major change.\n     */\n    protected pageIndexChanged(value: number): void {\n      this.pageIndex = value;\n    }\n\n    protected 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    protected 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.disabled || !this.hasPreviousPage()}\n            @click=${() => this.previousPage()}\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.disabled || !this.hasNextPage()}\n            @click=${() => this.nextPage()}\n          ></sbb-mini-button>\n        </sbb-mini-button-group>\n      `;\n    }\n\n    protected override render(): TemplateResult {\n      return html`\n        ${this.renderPaginator()}\n        <sbb-screen-reader-only role=\"status\"></sbb-screen-reader-only>\n      `;\n    }\n  }\n  return SbbPaginatorCommonElement as unknown as AbstractConstructor<SbbPaginatorCommonElementMixinType> &\n    T;\n};\n\ndeclare global {\n  interface HTMLElementEventMap {\n    page: CustomEvent<SbbPaginatorPageEventDetails>;\n  }\n}\n"],"names":["SbbPaginatorCommonElement"],"mappings":"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"}

package/development/paginator/compact-paginator/compact-paginator.component.d.ts

@@ -0,0 +1,20 @@
+import { CSSResultGroup, TemplateResult, LitElement } from 'lit';
+declare const SbbCompactPaginatorElement_base: import('../../core/mixins.js').AbstractConstructor<import('../common.js').SbbPaginatorCommonElementMixinType> & typeof LitElement;
+/**
+ * It displays a paginator component in compact mode.
+ *
+ * @event {CustomEvent<SbbPaginatorPageEventDetails>} page - Emits when the pageIndex changes.
+ */
+export declare class SbbCompactPaginatorElement extends SbbCompactPaginatorElement_base {
+    static styles: CSSResultGroup;
+    static readonly events: Record<string, string>;
+    private _renderPageNumbers;
+    protected renderPaginator(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-compact-paginator': SbbCompactPaginatorElement;
+    }
+}
+export {};
+//# sourceMappingURL=compact-paginator.component.d.ts.map

package/development/paginator/compact-paginator/compact-paginator.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact-paginator.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/paginator/compact-paginator/compact-paginator.component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1D,OAAO,EAAQ,UAAU,EAAE,MAAM,KAAK,CAAC;AAIvC,OAAO,kBAAkB,CAAC;;AAI1B;;;;GAIG;AACH,qBAEM,0BAA2B,SAAQ,+BAA0C;IACjF,OAAuB,MAAM,EAAE,cAAc,CAAS;IACtD,gBAAuB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAE1C;IAEX,OAAO,CAAC,kBAAkB;cAcP,eAAe,IAAI,cAAc;CASrD;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,uBAAuB,EAAE,0BAA0B,CAAC;KACrD;CACF"}

package/development/paginator/compact-paginator/compact-paginator.component.js

@@ -0,0 +1,96 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, LitElement, html } from "lit";
+import { customElement } from "lit/decorators.js";
+import { SbbPaginatorCommonElementMixin } from "../common.js";
+import "../../divider.js";
+const style = css`*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  display: block;
+  --sbb-compact-paginator-height: var(--sbb-size-element-m);
+  --sbb-compact-paginator-color: var(--sbb-color-metal);
+  --sbb-paginator-compact-justify-content: start;
+}
+
+:host([size=s]) {
+  --sbb-compact-paginator-height: var(--sbb-size-element-xs);
+}
+
+:host([negative]) {
+  --sbb-compact-paginator-color: var(--sbb-color-storm);
+}
+
+:host([pager-position=end]) {
+  --sbb-paginator-compact-justify-content: end;
+}
+
+.sbb-compact-paginator {
+  display: flex;
+  gap: var(--sbb-spacing-fixed-5x);
+  justify-content: var(--sbb-paginator-compact-justify-content);
+  min-height: var(--sbb-compact-paginator-height);
+}
+
+.sbb-paginator__pages {
+  --sbb-text-font-size: var(--sbb-font-size-text-m);
+  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;
+  justify-content: center;
+  gap: var(--sbb-spacing-fixed-2x);
+  color: var(--sbb-compact-paginator-color);
+}
+
+.sbb-compact-paginator__divider {
+  height: 1rem;
+}`;
+let SbbCompactPaginatorElement = (() => {
+  var _a;
+  let _classDecorators = [customElement("sbb-compact-paginator")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbPaginatorCommonElementMixin(LitElement);
+  _a = class extends _classSuper {
+    _renderPageNumbers() {
+      return html`
+      <span class="sbb-paginator__pages"
+        >${this.pageIndex + 1}<sbb-divider
+          aria-hidden="true"
+          orientation="vertical"
+          class="sbb-compact-paginator__divider"
+          ?negative=${this.negative}
+        ></sbb-divider
+        >${this.numberOfPages()}</span
+      >
+    `;
+    }
+    renderPaginator() {
+      return html`
+      <div class="sbb-compact-paginator">
+        ${this.pagerPosition === "start" ? html`${this.renderPrevNextButtons()} ${this._renderPageNumbers()}` : html`${this._renderPageNumbers()} ${this.renderPrevNextButtons()}`}
+      </div>
+    `;
+    }
+  }, _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    __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 {
+  SbbCompactPaginatorElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,5 +1,5 @@
 /**
  * @entrypoint
  */
-export * from './compact-paginator/compact-paginator.js';
+export * from './compact-paginator/compact-paginator.component.js';
 //# sourceMappingURL=compact-paginator.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compact-paginator.d.ts","sourceRoot":"","sources":["../../../../src/elements/paginator/compact-paginator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,0CAA0C,CAAC"}
+{"version":3,"file":"compact-paginator.d.ts","sourceRoot":"","sources":["../../../../src/elements/paginator/compact-paginator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,oDAAoD,CAAC"}

package/development/paginator/compact-paginator.js

@@ -1,4 +1,4 @@
-import { SbbCompactPaginatorElement } from "./compact-paginator/compact-paginator.js";
+import { SbbCompactPaginatorElement } from "./compact-paginator/compact-paginator.component.js";
 export {
   SbbCompactPaginatorElement
 };

package/development/paginator/paginator/paginator.component.d.ts

@@ -0,0 +1,47 @@
+import { CSSResultGroup, LitElement, PropertyValues, TemplateResult } from 'lit';
+declare const SbbPaginatorElement_base: import('../../core/mixins.js').AbstractConstructor<import('../common.js').SbbPaginatorCommonElementMixinType> & typeof LitElement;
+/**
+ * It displays a paginator component.
+ *
+ * @event {CustomEvent<SbbPaginatorPageEventDetails>} page - Emits when the pageIndex changes.
+ */
+export declare class SbbPaginatorElement extends SbbPaginatorElement_base {
+    static styles: CSSResultGroup;
+    static readonly events: Record<string, string>;
+    /** The available `pageSize` choices. */
+    accessor pageSizeOptions: number[];
+    /**
+     * 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.
+     */
+    accessor pagerPosition: 'start' | 'end';
+    private _markForFocus;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    /**
+     * If the `pageSize` changes due to user interaction with the `pageSizeOptions` select,
+     * emit the `page` event and then update the `pageSize` value.
+     */
+    private _pageSizeChanged;
+    /** Returns the displayed page elements. */
+    private _getVisiblePages;
+    /**
+     * 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.
+     */
+    private _getVisiblePagesIndex;
+    /** Creates an array of consecutive numbers given the length and the starting value. */
+    private _range;
+    private _handleKeyUp;
+    private _renderItemPerPageTemplate;
+    private _renderPageNumbers;
+    protected renderPaginator(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-paginator': SbbPaginatorElement;
+    }
+}
+export {};
+//# sourceMappingURL=paginator.component.d.ts.map

package/development/paginator/paginator/paginator.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginator.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/paginator/paginator/paginator.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAEnB,UAAU,EAEV,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;AAWb,OAAO,qBAAqB,CAAC;AAC7B,OAAO,iBAAiB,CAAC;AACzB,OAAO,iBAAiB,CAAC;AACzB,OAAO,6BAA6B,CAAC;;AAIrC;;;;GAIG;AACH,qBAEM,mBAAoB,SAAQ,wBAA0C;IAC1E,OAAuB,MAAM,EAAE,cAAc,CAAS;IACtD,gBAAuB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAE1C;IAEX,wCAAwC;IACxC,SACgB,eAAe,EAAE,MAAM,EAAE,CAAM;IAE/C;;;OAGG;IACH,SAAmF,aAAa,EAC5F,OAAO,GACP,KAAK,CAAW;IAEpB,OAAO,CAAC,aAAa,CAAuB;cAEzB,OAAO,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAgBzE;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAUxB,2CAA2C;IAC3C,OAAO,CAAC,gBAAgB;IAIxB;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IA2B7B,uFAAuF;IACvF,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,0BAA0B;IA8BlC,OAAO,CAAC,kBAAkB;cAiCP,eAAe,IAAI,cAAc;CAiBrD;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,eAAe,EAAE,mBAAmB,CAAC;KACtC;CACF"}