@decaf-ts/for-angular 0.0.9 → 0.0.10

package/dist/esm2022/components/pagination/pagination.component.mjs

@@ -0,0 +1,323 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { IonIcon } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { chevronBackOutline, chevronForwardOutline } from 'ionicons/icons';
+import { ForAngularModule } from '../../for-angular.module';
+import { NgxBaseComponent } from '../../engine/NgxBaseComponent';
+import { EventConstants } from '../../engine';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ngx-translate/core";
+/**
+ * @description A pagination component for navigating through multiple pages of content.
+ * @summary This component provides a user interface for paginated content navigation,
+ * displaying page numbers and navigation controls. It supports customizable page counts,
+ * current page tracking, and emits events when users navigate between pages.
+ *
+ * The component intelligently handles large numbers of pages by showing a subset of page
+ * numbers with ellipses to indicate skipped pages, ensuring the UI remains clean and usable
+ * even with many pages.
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User
+ *   participant P as PaginationComponent
+ *   participant E as External Component
+ *
+ *   U->>P: Click page number
+ *   P->>P: navigate(page)
+ *   P->>P: handleClick(direction, page)
+ *   P->>E: Emit clickEvent with PaginationCustomEvent
+ *
+ *   U->>P: Click next button
+ *   P->>P: next()
+ *   P->>P: handleClick('next')
+ *   P->>E: Emit clickEvent with PaginationCustomEvent
+ *
+ *   U->>P: Click previous button
+ *   P->>P: previous()
+ *   P->>P: handleClick('previous')
+ *   P->>E: Emit clickEvent with PaginationCustomEvent
+ *
+ * @example
+ * <ngx-decaf-pagination
+ *   [pages]="10"
+ *   [current]="3"
+ *   (clickEvent)="handlePageChange($event)">
+ * </ngx-decaf-pagination>
+ *
+ * @extends {NgxBaseComponent}
+ * @implements {OnInit}
+ */
+export class PaginationComponent extends NgxBaseComponent {
+    /**
+     * @constructor
+     * @description Initializes a new instance of the PaginationComponent.
+     * Calls the parent constructor with the component name for generate base locale string.
+     */
+    constructor() {
+        super("PaginationComponent");
+        /**
+         * @description Controls whether the component uses translation services.
+         * @summary When set to true, the component will attempt to use translation services
+         * for any text content. This allows for internationalization of the pagination component.
+         *
+         * @type {StringOrBoolean}
+         * @default true
+         * @memberOf PaginationComponent
+         */
+        this.translatable = true;
+        /**
+         * @description The currently active page number.
+         * @summary Specifies which page is currently active or selected. This value is used
+         * to highlight the current page in the UI and as a reference point for navigation.
+         *
+         * @type {number}
+         * @default 1
+         * @memberOf PaginationComponent
+         */
+        this.current = 1;
+        /**
+         * @description Event emitter for pagination navigation events.
+         * @summary Emits a custom event when users navigate between pages, either by clicking
+         * on page numbers or using the next/previous buttons. The event contains information
+         * about the navigation direction and the target page number.
+         *
+         * @type {EventEmitter<PaginationCustomEvent>}
+         * @memberOf PaginationComponent
+         */
+        this.clickEvent = new EventEmitter();
+        addIcons({ chevronBackOutline, chevronForwardOutline });
+    }
+    /**
+     * @description Initializes the component after Angular sets the input properties.
+     * @summary Sets up the component by initializing the locale settings based on the
+     * translatable property, generating the page numbers based on the total pages and
+     * current page, and storing the last page number for boundary checking.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Angular Lifecycle
+     *   participant P as PaginationComponent
+     *
+     *   A->>P: ngOnInit()
+     *   P->>P: getLocale(translatable)
+     *   P->>P: Set locale
+     *   P->>P: getPages(data, current)
+     *   P->>P: Set pages array
+     *   P->>P: Set last page number
+     *
+     * @returns {void}
+     * @memberOf PaginationComponent
+     */
+    ngOnInit() {
+        this.locale = this.getLocale(this.translatable);
+        this.pages = this.getPages(this.totalPages, this.current);
+        this.last = this.totalPages;
+    }
+    /**
+     * @description Handles click events on pagination controls.
+     * @summary Processes user interactions with the pagination component, updating the
+     * current page if specified and emitting an event with navigation details. This method
+     * is called when users click on page numbers or navigation buttons.
+     *
+     * @param {('next' | 'previous')} direction - The direction of navigation
+     * @param {number} [page] - Optional page number to navigate to directly
+     * @returns {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant P as PaginationComponent
+     *   participant E as External Component
+     *
+     *   U->>P: Click pagination control
+     *   P->>P: handleClick(direction, page?)
+     *   alt page is provided
+     *     P->>P: Update current page
+     *   end
+     *   P->>E: Emit clickEvent with direction and page
+     *
+     * @memberOf PaginationComponent
+     */
+    handleClick(direction, page) {
+        if (page)
+            this.current = page;
+        this.clickEvent.emit({
+            name: EventConstants.CLICK_EVENT,
+            data: {
+                direction,
+                page: this.current
+            },
+            component: this.componentName
+        });
+    }
+    /**
+     * @description Generates the array of page objects for display.
+     * @summary Creates an array of page objects based on the total number of pages and
+     * the current page. For small page counts (≤5), all pages are shown. For larger page
+     * counts, a subset is shown with ellipses to indicate skipped pages. This ensures
+     * the pagination UI remains clean and usable even with many pages.
+     *
+     * @param {number} total - The total number of pages
+     * @param {number} [current] - The current active page (defaults to this.current)
+     * @returns {KeyValue[]} Array of page objects with index and text properties
+     *
+     * @mermaid
+     * flowchart TD
+     *   A[Start] --> B{total <= 5?}
+     *   B -->|Yes| C[Show all pages]
+     *   B -->|No| D[Show first page]
+     *   D --> E[Show last pages]
+     *   E --> F[Add ellipses for skipped pages]
+     *   C --> G[Return pages array]
+     *   F --> G
+     *
+     * @memberOf PaginationComponent
+     */
+    getPages(total, current) {
+        if (!current)
+            current = this.current;
+        const pages = [];
+        function getPage(index, text = '') {
+            if (pages.some(item => item['index'] === index))
+                return;
+            pages.push({ index, text: index != null ? index.toString().padStart(2, '0') : text });
+        }
+        if (total <= 5) {
+            for (let i = 1; i <= total; i++)
+                getPage(i);
+        }
+        else {
+            // Adiciona os dois primeiros
+            getPage(1);
+            getPage(2);
+            // Adiciona "..." entre os blocos
+            if (current && current > 3)
+                getPage(null, '...');
+            // Adiciona a página atual (se estiver no meio)
+            if (current && current > 2 && current < total - 1)
+                getPage(current);
+            // Adiciona "..." entre os blocos
+            if (current && current < total - 2)
+                getPage(null, '...');
+            // Adiciona os dois últimos
+            getPage(total - 1);
+            getPage(total);
+        }
+        return pages;
+    }
+    /**
+     * @description Gets the current active page number.
+     * @summary Returns the current page number that is active in the pagination component.
+     * This method provides a way to access the current page state from outside the component.
+     *
+     * @returns {number} The current page number
+     * @memberOf PaginationComponent
+     */
+    getCurrent() {
+        return this.current;
+    }
+    /**
+     * @description Navigates to the next page.
+     * @summary Increments the current page number if not at the last page and triggers
+     * the click event handler with 'next' direction. This method is typically called
+     * when the user clicks on the "next" button in the pagination UI.
+     *
+     * @returns {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant P as PaginationComponent
+     *
+     *   U->>P: Click next button
+     *   P->>P: next()
+     *   alt page <= max pages
+     *     P->>P: Increment current page
+     *     P->>P: handleClick('next')
+     *   end
+     *
+     * @memberOf PaginationComponent
+     */
+    next() {
+        const page = this.current + 1;
+        if (page <= Object.keys(this.pages)?.length || 0) {
+            this.current = page;
+            this.handleClick('next');
+        }
+    }
+    /**
+     * @description Navigates to the previous page.
+     * @summary Decrements the current page number if not at the first page and triggers
+     * the click event handler with 'previous' direction. This method is typically called
+     * when the user clicks on the "previous" button in the pagination UI.
+     *
+     * @returns {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant P as PaginationComponent
+     *
+     *   U->>P: Click previous button
+     *   P->>P: previous()
+     *   alt page > 0
+     *     P->>P: Decrement current page
+     *     P->>P: handleClick('previous')
+     *   end
+     *
+     * @memberOf PaginationComponent
+     */
+    previous() {
+        const page = this.current - 1;
+        if (page > 0) {
+            this.current = page;
+            this.handleClick('previous');
+        }
+    }
+    /**
+     * @description Navigates to a specific page number.
+     * @summary Updates the current page to the specified page number and triggers
+     * the click event handler with the appropriate direction. This method is typically
+     * called when the user clicks directly on a page number in the pagination UI.
+     *
+     * @param {number | null} page - The page number to navigate to
+     * @returns {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant P as PaginationComponent
+     *
+     *   U->>P: Click page number
+     *   P->>P: navigate(page)
+     *   alt page is not null and different from current
+     *     P->>P: Determine direction (next/previous)
+     *     P->>P: handleClick(direction, page)
+     *   end
+     *
+     * @memberOf PaginationComponent
+     */
+    navigate(page) {
+        if (page !== null && this.current !== page)
+            this.handleClick(page > this.current ? 'next' : 'previous', page);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PaginationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: PaginationComponent, isStandalone: true, selector: "ngx-decaf-pagination", inputs: { totalPages: "totalPages", current: "current" }, outputs: { clickEvent: "clickEvent" }, usesInheritance: true, ngImport: i0, template: " <div id=\"dcf-paginator-container\" class=\"dcf-flex dcf-flex-center\">\n  <div class=\"dcf-width-1-1\">\n    <div class=\"dcf-pagination-resume\" [innerHTML]=\"locale + '.resume' | translate: {value0: current, value1: last}\"></div>\n    <div #paginationComponent class=\"dcf-pagination aeon-pagination dcf-flex-center\">\n      <div\n        aria-label=\"previous\"\n        tabindex=\"0\"\n        (click)=\"previous()\"\n        (keydown.enter)=\"previous()\" [ngClass]=\"{'dcf-disabled': current === 1}\">\n        <ion-icon name=\"chevron-back-outline\" aria-hidden=\"true\"></ion-icon>\n      </div>\n      @for(page of pages; track page) {\n        <div tabindex=\"0\" (click)=\"navigate(page['index'])\"\n          (keydown.enter)=\"navigate(page['index'])\"\n          [ngClass]=\"{'dcf-active': current === page['index'], 'dcf-disabled': page['index'] === ndivl}\">\n          <span class=\"page-item\">{{ page['text'] }}</span>\n        </div>\n      }\n      <div\n        tabindex=\"0\" (click)=\"next()\"\n        (keydown.enter)=\"next()\"\n        [ngClass]=\"{'dcf-disabled': current === last}\">\n        <ion-icon name=\"chevron-forward-outline\" aria-hidden=\"true\"></ion-icon>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: ["#dcf-paginator-container{margin-bottom:1rem}.dcf-pagination{display:flex;flex-wrap:wrap;align-items:center;margin-left:0;padding:0;list-style:none}.dcf-pagination .page-item{display:flex;justify-content:center;align-items:top;color:var(--ion-color-gray-7);font-weight:600;width:36px;line-height:34px;padding:0!important;border-radius:50%;box-sizing:border-box}.dcf-pagination>*{flex:none;padding-left:0;position:relative;margin:0px .15rem}.dcf-pagination>*:not(.disabled){cursor:pointer}.dcf-pagination>*:hover .page-item{color:var(--ion-color-primary)}.dcf-pagination>* .page-item{color:var(--ion-color-gray-7);font-weight:600}.dcf-pagination>*.dcf-active .page-item{background:rgba(var(--ion-color-primary-rgb),.15)}.dcf-pagination>*>*{display:flex;align-items:center;column-gap:.25em;padding:5px 10px;color:var(--ion-color-gray-8);transition:color .1s ease-in-out}.dcf-pagination>*>:hover{color:var(--ion-color-gray-6);text-decoration:none}.dcf-pagination .dcf-disabled>*{opacity:.5;color:var(--ion-color-gray-6)}.dcf-pagination-resume{color:var(--ion-color-gray-8);margin:1rem 0px;text-align:center}\n"], dependencies: [{ kind: "ngmodule", type: ForAngularModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PaginationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-decaf-pagination', imports: [
+                        ForAngularModule,
+                        IonIcon
+                    ], standalone: true, template: " <div id=\"dcf-paginator-container\" class=\"dcf-flex dcf-flex-center\">\n  <div class=\"dcf-width-1-1\">\n    <div class=\"dcf-pagination-resume\" [innerHTML]=\"locale + '.resume' | translate: {value0: current, value1: last}\"></div>\n    <div #paginationComponent class=\"dcf-pagination aeon-pagination dcf-flex-center\">\n      <div\n        aria-label=\"previous\"\n        tabindex=\"0\"\n        (click)=\"previous()\"\n        (keydown.enter)=\"previous()\" [ngClass]=\"{'dcf-disabled': current === 1}\">\n        <ion-icon name=\"chevron-back-outline\" aria-hidden=\"true\"></ion-icon>\n      </div>\n      @for(page of pages; track page) {\n        <div tabindex=\"0\" (click)=\"navigate(page['index'])\"\n          (keydown.enter)=\"navigate(page['index'])\"\n          [ngClass]=\"{'dcf-active': current === page['index'], 'dcf-disabled': page['index'] === ndivl}\">\n          <span class=\"page-item\">{{ page['text'] }}</span>\n        </div>\n      }\n      <div\n        tabindex=\"0\" (click)=\"next()\"\n        (keydown.enter)=\"next()\"\n        [ngClass]=\"{'dcf-disabled': current === last}\">\n        <ion-icon name=\"chevron-forward-outline\" aria-hidden=\"true\"></ion-icon>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: ["#dcf-paginator-container{margin-bottom:1rem}.dcf-pagination{display:flex;flex-wrap:wrap;align-items:center;margin-left:0;padding:0;list-style:none}.dcf-pagination .page-item{display:flex;justify-content:center;align-items:top;color:var(--ion-color-gray-7);font-weight:600;width:36px;line-height:34px;padding:0!important;border-radius:50%;box-sizing:border-box}.dcf-pagination>*{flex:none;padding-left:0;position:relative;margin:0px .15rem}.dcf-pagination>*:not(.disabled){cursor:pointer}.dcf-pagination>*:hover .page-item{color:var(--ion-color-primary)}.dcf-pagination>* .page-item{color:var(--ion-color-gray-7);font-weight:600}.dcf-pagination>*.dcf-active .page-item{background:rgba(var(--ion-color-primary-rgb),.15)}.dcf-pagination>*>*{display:flex;align-items:center;column-gap:.25em;padding:5px 10px;color:var(--ion-color-gray-8);transition:color .1s ease-in-out}.dcf-pagination>*>:hover{color:var(--ion-color-gray-6);text-decoration:none}.dcf-pagination .dcf-disabled>*{opacity:.5;color:var(--ion-color-gray-6)}.dcf-pagination-resume{color:var(--ion-color-gray-8);margin:1rem 0px;text-align:center}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { totalPages: [{
+                type: Input,
+                args: [{ required: true }]
+            }], current: [{
+                type: Input
+            }], clickEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.component.js","sourceRoot":"","sources":["../../../../src/lib/components/pagination/pagination.component.ts","../../../../src/lib/components/pagination/pagination.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { IonIcon } from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { chevronBackOutline, chevronForwardOutline } from 'ionicons/icons';\nimport { ForAngularModule } from '../../for-angular.module';\nimport { NgxBaseComponent } from '../../engine/NgxBaseComponent';\nimport { EventConstants, KeyValue, StringOrBoolean } from '../../engine';\nimport { PaginationCustomEvent } from './constants';\n\n/**\n * @description A pagination component for navigating through multiple pages of content.\n * @summary This component provides a user interface for paginated content navigation,\n * displaying page numbers and navigation controls. It supports customizable page counts,\n * current page tracking, and emits events when users navigate between pages.\n *\n * The component intelligently handles large numbers of pages by showing a subset of page\n * numbers with ellipses to indicate skipped pages, ensuring the UI remains clean and usable\n * even with many pages.\n *\n * @mermaid\n * sequenceDiagram\n *   participant U as User\n *   participant P as PaginationComponent\n *   participant E as External Component\n *\n *   U->>P: Click page number\n *   P->>P: navigate(page)\n *   P->>P: handleClick(direction, page)\n *   P->>E: Emit clickEvent with PaginationCustomEvent\n *\n *   U->>P: Click next button\n *   P->>P: next()\n *   P->>P: handleClick('next')\n *   P->>E: Emit clickEvent with PaginationCustomEvent\n *\n *   U->>P: Click previous button\n *   P->>P: previous()\n *   P->>P: handleClick('previous')\n *   P->>E: Emit clickEvent with PaginationCustomEvent\n *\n * @example\n * <ngx-decaf-pagination\n *   [pages]=\"10\"\n *   [current]=\"3\"\n *   (clickEvent)=\"handlePageChange($event)\">\n * </ngx-decaf-pagination>\n *\n * @extends {NgxBaseComponent}\n * @implements {OnInit}\n */\n@Component({\n  selector: 'ngx-decaf-pagination',\n  templateUrl: './pagination.component.html',\n  styleUrls: ['./pagination.component.scss'],\n  imports: [\n    ForAngularModule,\n    IonIcon\n  ],\n  standalone: true,\n\n})\nexport class PaginationComponent extends NgxBaseComponent implements OnInit {\n\n  /**\n   * @description Controls whether the component uses translation services.\n   * @summary When set to true, the component will attempt to use translation services\n   * for any text content. This allows for internationalization of the pagination component.\n   *\n   * @type {StringOrBoolean}\n   * @default true\n   * @memberOf PaginationComponent\n   */\n  override translatable: StringOrBoolean = true;\n\n  /**\n   * @description The total number of pages to display in the pagination component.\n   * @summary Specifies the total number of pages available for navigation. This is a required\n   * input that determines how many page numbers will be generated and displayed.\n   *\n   * @type {number}\n   * @required\n   * @memberOf PaginationComponent\n   */\n  @Input({ required: true })\n  totalPages!: number;\n\n  /**\n   * @description The currently active page number.\n   * @summary Specifies which page is currently active or selected. This value is used\n   * to highlight the current page in the UI and as a reference point for navigation.\n   *\n   * @type {number}\n   * @default 1\n   * @memberOf PaginationComponent\n   */\n  @Input()\n  current = 1;\n\n  /**\n   * @description Array of page objects for rendering in the template.\n   * @summary Contains the processed page data used for rendering the pagination UI.\n   * Each object includes an index (page number) and text representation.\n   *\n   * @type {KeyValue[]}\n   * @memberOf PaginationComponent\n   */\n  pages!: KeyValue[];\n\n  /**\n   * @description The last page number in the pagination.\n   * @summary Stores the number of the last page for boundary checking during navigation.\n   *\n   * @type {number}\n   * @memberOf PaginationComponent\n   */\n  last!: number;\n\n  /**\n   * @description Event emitter for pagination navigation events.\n   * @summary Emits a custom event when users navigate between pages, either by clicking\n   * on page numbers or using the next/previous buttons. The event contains information\n   * about the navigation direction and the target page number.\n   *\n   * @type {EventEmitter<PaginationCustomEvent>}\n   * @memberOf PaginationComponent\n   */\n  @Output()\n  clickEvent: EventEmitter<PaginationCustomEvent> = new EventEmitter<PaginationCustomEvent>();\n\n  /**\n   * @constructor\n   * @description Initializes a new instance of the PaginationComponent.\n   * Calls the parent constructor with the component name for generate base locale string.\n   */\n  constructor() {\n    super(\"PaginationComponent\");\n     addIcons({chevronBackOutline, chevronForwardOutline});\n  }\n\n  /**\n   * @description Initializes the component after Angular sets the input properties.\n   * @summary Sets up the component by initializing the locale settings based on the\n   * translatable property, generating the page numbers based on the total pages and\n   * current page, and storing the last page number for boundary checking.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Angular Lifecycle\n   *   participant P as PaginationComponent\n   *\n   *   A->>P: ngOnInit()\n   *   P->>P: getLocale(translatable)\n   *   P->>P: Set locale\n   *   P->>P: getPages(data, current)\n   *   P->>P: Set pages array\n   *   P->>P: Set last page number\n   *\n   * @returns {void}\n   * @memberOf PaginationComponent\n   */\n  ngOnInit(): void {\n    this.locale = this.getLocale(this.translatable);\n    this.pages = this.getPages(this.totalPages, this.current) as KeyValue[];\n    this.last = this.totalPages;\n  }\n\n  /**\n   * @description Handles click events on pagination controls.\n   * @summary Processes user interactions with the pagination component, updating the\n   * current page if specified and emitting an event with navigation details. This method\n   * is called when users click on page numbers or navigation buttons.\n   *\n   * @param {('next' | 'previous')} direction - The direction of navigation\n   * @param {number} [page] - Optional page number to navigate to directly\n   * @returns {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant P as PaginationComponent\n   *   participant E as External Component\n   *\n   *   U->>P: Click pagination control\n   *   P->>P: handleClick(direction, page?)\n   *   alt page is provided\n   *     P->>P: Update current page\n   *   end\n   *   P->>E: Emit clickEvent with direction and page\n   *\n   * @memberOf PaginationComponent\n   */\n  handleClick(direction: 'next' | 'previous', page?: number): void {\n    if(page)\n      this.current = page;\n    this.clickEvent.emit({\n      name: EventConstants.CLICK_EVENT,\n      data: {\n        direction,\n        page: this.current\n      },\n      component: this.componentName\n    } as PaginationCustomEvent);\n  }\n\n  /**\n   * @description Generates the array of page objects for display.\n   * @summary Creates an array of page objects based on the total number of pages and\n   * the current page. For small page counts (≤5), all pages are shown. For larger page\n   * counts, a subset is shown with ellipses to indicate skipped pages. This ensures\n   * the pagination UI remains clean and usable even with many pages.\n   *\n   * @param {number} total - The total number of pages\n   * @param {number} [current] - The current active page (defaults to this.current)\n   * @returns {KeyValue[]} Array of page objects with index and text properties\n   *\n   * @mermaid\n   * flowchart TD\n   *   A[Start] --> B{total <= 5?}\n   *   B -->|Yes| C[Show all pages]\n   *   B -->|No| D[Show first page]\n   *   D --> E[Show last pages]\n   *   E --> F[Add ellipses for skipped pages]\n   *   C --> G[Return pages array]\n   *   F --> G\n   *\n   * @memberOf PaginationComponent\n   */\n  getPages(total: number, current?: number): KeyValue[] {\n    if (!current) current = this.current;\n\n    const pages: KeyValue[] = [];\n\n    function getPage(index: number | null, text = '') {\n        if (pages.some(item => item['index'] === index)) return;\n        pages.push({ index, text: index != null ? index.toString().padStart(2, '0') : text });\n    }\n\n    if (total <= 5) {\n        for (let i = 1; i <= total; i++) getPage(i);\n    } else {\n      // Adiciona os dois primeiros\n      getPage(1);\n      getPage(2);\n\n      // Adiciona \"...\" entre os blocos\n      if (current && current > 3) getPage(null, '...');\n\n      // Adiciona a página atual (se estiver no meio)\n      if (current && current > 2 && current < total - 1) getPage(current);\n\n      // Adiciona \"...\" entre os blocos\n      if (current && current < total - 2) getPage(null, '...');\n\n      // Adiciona os dois últimos\n      getPage(total - 1);\n      getPage(total);\n    }\n\n    return pages;\n  }\n\n  /**\n   * @description Gets the current active page number.\n   * @summary Returns the current page number that is active in the pagination component.\n   * This method provides a way to access the current page state from outside the component.\n   *\n   * @returns {number} The current page number\n   * @memberOf PaginationComponent\n   */\n  getCurrent(): number {\n    return this.current;\n  }\n\n  /**\n   * @description Navigates to the next page.\n   * @summary Increments the current page number if not at the last page and triggers\n   * the click event handler with 'next' direction. This method is typically called\n   * when the user clicks on the \"next\" button in the pagination UI.\n   *\n   * @returns {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant P as PaginationComponent\n   *\n   *   U->>P: Click next button\n   *   P->>P: next()\n   *   alt page <= max pages\n   *     P->>P: Increment current page\n   *     P->>P: handleClick('next')\n   *   end\n   *\n   * @memberOf PaginationComponent\n   */\n  next(): void {\n    const page = this.current + 1;\n    if(page <= Object.keys(this.pages)?.length || 0) {\n      this.current = page;\n      this.handleClick('next');\n    }\n  }\n\n  /**\n   * @description Navigates to the previous page.\n   * @summary Decrements the current page number if not at the first page and triggers\n   * the click event handler with 'previous' direction. This method is typically called\n   * when the user clicks on the \"previous\" button in the pagination UI.\n   *\n   * @returns {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant P as PaginationComponent\n   *\n   *   U->>P: Click previous button\n   *   P->>P: previous()\n   *   alt page > 0\n   *     P->>P: Decrement current page\n   *     P->>P: handleClick('previous')\n   *   end\n   *\n   * @memberOf PaginationComponent\n   */\n  previous(): void {\n    const page = this.current - 1;\n    if(page > 0) {\n      this.current = page;\n      this.handleClick('previous');\n    }\n  }\n\n  /**\n   * @description Navigates to a specific page number.\n   * @summary Updates the current page to the specified page number and triggers\n   * the click event handler with the appropriate direction. This method is typically\n   * called when the user clicks directly on a page number in the pagination UI.\n   *\n   * @param {number | null} page - The page number to navigate to\n   * @returns {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant P as PaginationComponent\n   *\n   *   U->>P: Click page number\n   *   P->>P: navigate(page)\n   *   alt page is not null and different from current\n   *     P->>P: Determine direction (next/previous)\n   *     P->>P: handleClick(direction, page)\n   *   end\n   *\n   * @memberOf PaginationComponent\n   */\n  navigate(page: number | null): void {\n    if(page !== null && this.current !== page as number)\n      this.handleClick(page > this.current ? 'next' : 'previous', page);\n  }\n}\n"," <div id=\"dcf-paginator-container\" class=\"dcf-flex dcf-flex-center\">\n  <div class=\"dcf-width-1-1\">\n    <div class=\"dcf-pagination-resume\" [innerHTML]=\"locale + '.resume' | translate: {value0: current, value1: last}\"></div>\n    <div #paginationComponent class=\"dcf-pagination aeon-pagination dcf-flex-center\">\n      <div\n        aria-label=\"previous\"\n        tabindex=\"0\"\n        (click)=\"previous()\"\n        (keydown.enter)=\"previous()\" [ngClass]=\"{'dcf-disabled': current === 1}\">\n        <ion-icon name=\"chevron-back-outline\" aria-hidden=\"true\"></ion-icon>\n      </div>\n      @for(page of pages; track page) {\n        <div tabindex=\"0\" (click)=\"navigate(page['index'])\"\n          (keydown.enter)=\"navigate(page['index'])\"\n          [ngClass]=\"{'dcf-active': current === page['index'], 'dcf-disabled': page['index'] === ndivl}\">\n          <span class=\"page-item\">{{ page['text'] }}</span>\n        </div>\n      }\n      <div\n        tabindex=\"0\" (click)=\"next()\"\n        (keydown.enter)=\"next()\"\n        [ngClass]=\"{'dcf-disabled': current === last}\">\n        <ion-icon name=\"chevron-forward-outline\" aria-hidden=\"true\"></ion-icon>\n      </div>\n    </div>\n  </div>\n</div>\n"]}