@decaf-ts/for-angular 0.0.12 → 0.0.14

package/esm2022/components/model-renderer/model-renderer.component.mjs

@@ -0,0 +1,138 @@
+import { Component, EventEmitter, inject, Injector, Input, Output, TemplateRef, ViewChild, ViewContainerRef, } from '@angular/core';
+import { Model, sf } from '@decaf-ts/decorator-validation';
+import { NgComponentOutlet } from '@angular/common';
+import { AngularEngineKeys, BaseComponentProps, NgxRenderingEngine2, } from '../../engine';
+import { ForAngularModule } from '../../for-angular.module';
+import { ComponentRendererComponent } from '../component-renderer/component-renderer.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * @description Component for rendering dynamic models
+ * @summary This component is responsible for dynamically rendering models,
+ * handling model changes, and managing event subscriptions for the rendered components.
+ * It uses the NgxRenderingEngine2 to render the models and supports both string and Model inputs.
+ * @class
+ * @template M - Type extending Model
+ * @param {Injector} injector - Angular Injector for dependency injection
+ * @example
+ * <ngx-decaf-model-renderer
+ *   [model]="myModel"
+ *   [globals]="globalVariables"
+ *   (listenEvent)="handleEvent($event)">
+ * </ngx-decaf-model-renderer>
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant ModelRenderer
+ *   participant RenderingEngine
+ *   participant Model
+ *   App->>ModelRenderer: Input model
+ *   ModelRenderer->>Model: Parse if string
+ *   Model-->>ModelRenderer: Parsed model
+ *   ModelRenderer->>RenderingEngine: Render model
+ *   RenderingEngine-->>ModelRenderer: Rendered output
+ *   ModelRenderer->>ModelRenderer: Subscribe to events
+ *   ModelRenderer-->>App: Emit events
+ */
+export class ModelRendererComponent {
+    constructor() {
+        /**
+         * @description Global variables to be passed to the rendered component
+         */
+        this.globals = {};
+        /**
+         * @description Event emitter for custom events from the rendered component
+         */
+        this.listenEvent = new EventEmitter();
+        this.injector = inject(Injector);
+        this.JSON = JSON;
+    }
+    // constructor() {}
+    /**
+     * @description Refreshes the rendered model
+     * @param {string | M} model - The model to be rendered
+     */
+    refresh(model) {
+        model =
+            typeof model === 'string'
+                ? Model.build({}, model)
+                : model;
+        this.output = model.render(this.globals || {}, this.vcr, this.injector, this.inner);
+        if (this.output?.inputs)
+            this.rendererId = sf(AngularEngineKeys.RENDERED_ID, this.output.inputs['rendererId']);
+        this.instance = this.output?.instance;
+        this.subscribeEvents();
+    }
+    /**
+     * @description Lifecycle hook that is called when data-bound properties of a directive change
+     * @param {SimpleChanges} changes - Object containing changes
+     */
+    ngOnChanges(changes) {
+        if (changes[BaseComponentProps.MODEL]) {
+            const { currentValue } = changes[BaseComponentProps.MODEL];
+            this.refresh(currentValue);
+        }
+    }
+    /**
+     * @description Lifecycle hook that is called when a directive, pipe, or service is destroyed
+     * @return {Promise<void>}
+     */
+    async ngOnDestroy() {
+        if (this.instance) {
+            this.unsubscribeEvents();
+            await NgxRenderingEngine2.destroy();
+        }
+        this.output = undefined;
+    }
+    subscribeEvents() {
+        if (this.instance) {
+            const componentKeys = Object.keys(this.instance);
+            for (const key of componentKeys) {
+                const value = this.instance[key];
+                if (value instanceof EventEmitter)
+                    this.instance[key].subscribe((event) => {
+                        this.listenEvent.emit({
+                            component: this.output?.component.name || '',
+                            name: key,
+                            ...event,
+                        });
+                    });
+            }
+        }
+    }
+    /**
+     * @description Unsubscribes from events emitted by the rendered component
+     */
+    unsubscribeEvents() {
+        if (this.instance) {
+            const componentKeys = Object.keys(this.instance);
+            for (const key of componentKeys) {
+                const value = this.instance[key];
+                if (value instanceof EventEmitter)
+                    this.instance[key].unsubscribe();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ModelRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ModelRendererComponent, isStandalone: true, selector: "ngx-decaf-model-renderer", inputs: { model: "model", globals: "globals", rendererId: "rendererId" }, outputs: { listenEvent: "listenEvent" }, viewQueries: [{ propertyName: "inner", first: true, predicate: ["inner"], descendants: true, read: TemplateRef, static: true }, { propertyName: "vcr", first: true, predicate: ["componentOuter"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, ngImport: i0, template: "  <ng-template #componentOuter></ng-template>\n  <ng-template #inner>\n    <div  [id]=\"rendererId || null\">\n      @for (child of output?.children; track child) {\n        @if(child?.children?.length) {\n          <ngx-decaf-component-renderer [parent]=\"child\" />\n        } @else {\n          <ng-container\n            #childComponents\n            *ngComponentOutlet=\"\n              child.component;\n              injector: child.injector;\n              inputs: child.inputs;\n              content:child.content;\n            \"\n          />\n        }\n      }\n    </div>\n  </ng-template>\n", styles: [""], dependencies: [{ kind: "ngmodule", type: ForAngularModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "component", type: ComponentRendererComponent, selector: "ngx-decaf-component-renderer", inputs: ["tag", "globals", "model", "parent"], outputs: ["listenEvent"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ModelRendererComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [ForAngularModule, NgComponentOutlet, ComponentRendererComponent], selector: 'ngx-decaf-model-renderer', template: "  <ng-template #componentOuter></ng-template>\n  <ng-template #inner>\n    <div  [id]=\"rendererId || null\">\n      @for (child of output?.children; track child) {\n        @if(child?.children?.length) {\n          <ngx-decaf-component-renderer [parent]=\"child\" />\n        } @else {\n          <ng-container\n            #childComponents\n            *ngComponentOutlet=\"\n              child.component;\n              injector: child.injector;\n              inputs: child.inputs;\n              content:child.content;\n            \"\n          />\n        }\n      }\n    </div>\n  </ng-template>\n" }]
+        }], propDecorators: { model: [{
+                type: Input,
+                args: [{ required: true }]
+            }], globals: [{
+                type: Input
+            }], inner: [{
+                type: ViewChild,
+                args: ['inner', { read: TemplateRef, static: true }]
+            }], rendererId: [{
+                type: Input
+            }], vcr: [{
+                type: ViewChild,
+                args: ['componentOuter', { static: true, read: ViewContainerRef }]
+            }], listenEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-renderer.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/model-renderer/model-renderer.component.ts","../../../../../src/lib/components/model-renderer/model-renderer.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  EventEmitter,\n  inject,\n  Injector,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  TemplateRef,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { Model, sf } from '@decaf-ts/decorator-validation';\nimport { NgComponentOutlet } from '@angular/common';\nimport {\n  AngularDynamicOutput,\n  AngularEngineKeys,\n  BaseComponentProps,\n  BaseCustomEvent,\n  NgxRenderingEngine2,\n  RenderedModel,\n} from '../../engine';\nimport { KeyValue, RendererCustomEvent } from '../../engine/types';\nimport { ForAngularModule } from '../../for-angular.module';\nimport { Renderable } from '@decaf-ts/ui-decorators';\nimport { ComponentRendererComponent } from '../component-renderer/component-renderer.component';\n\n/**\n * @description Component for rendering dynamic models\n * @summary This component is responsible for dynamically rendering models,\n * handling model changes, and managing event subscriptions for the rendered components.\n * It uses the NgxRenderingEngine2 to render the models and supports both string and Model inputs.\n * @class\n * @template M - Type extending Model\n * @param {Injector} injector - Angular Injector for dependency injection\n * @example\n * <ngx-decaf-model-renderer\n *   [model]=\"myModel\"\n *   [globals]=\"globalVariables\"\n *   (listenEvent)=\"handleEvent($event)\">\n * </ngx-decaf-model-renderer>\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant ModelRenderer\n *   participant RenderingEngine\n *   participant Model\n *   App->>ModelRenderer: Input model\n *   ModelRenderer->>Model: Parse if string\n *   Model-->>ModelRenderer: Parsed model\n *   ModelRenderer->>RenderingEngine: Render model\n *   RenderingEngine-->>ModelRenderer: Rendered output\n *   ModelRenderer->>ModelRenderer: Subscribe to events\n *   ModelRenderer-->>App: Emit events\n */\n@Component({\n  standalone: true,\n  imports: [ForAngularModule, NgComponentOutlet, ComponentRendererComponent],\n  selector: 'ngx-decaf-model-renderer',\n  templateUrl: './model-renderer.component.html',\n  styleUrl: './model-renderer.component.scss',\n})\nexport class ModelRendererComponent<M extends Model>\n  implements OnChanges, OnDestroy, RenderedModel {\n\n  /**\n   * @description Input model to be rendered\n   * @summary Can be a Model instance or a JSON string representation of a model\n   */\n  @Input({ required: true })\n  model!: M | string | undefined;\n\n  /**\n   * @description Global variables to be passed to the rendered component\n   */\n  @Input()\n  globals: Record<string, unknown> = {};\n\n  /**\n   * @description Template reference for inner content\n   */\n  @ViewChild('inner', { read: TemplateRef, static: true })\n  inner?: TemplateRef<unknown>;\n\n  /**\n   * @description Output of the rendered model\n   */\n  output?: AngularDynamicOutput;\n\n  /**\n   * @description Unique identifier for the renderer\n   */\n  @Input()\n  rendererId?: string;\n\n  /**\n   * @description View container reference for dynamic component rendering\n   */\n  @ViewChild('componentOuter', { static: true, read: ViewContainerRef })\n  vcr!: ViewContainerRef;\n\n  /**\n   * @description Event emitter for custom events from the rendered component\n   */\n  @Output()\n  listenEvent = new EventEmitter<RendererCustomEvent>();\n\n  /**\n   * @description Instance of the NgxRenderingEngine2\n   */\n  private render!: NgxRenderingEngine2;\n\n  /**\n   * @description Instance of the rendered component\n   */\n  private instance!: KeyValue | undefined;\n\n  private injector: Injector = inject(Injector);\n\n  // constructor() {}\n\n  /**\n   * @description Refreshes the rendered model\n   * @param {string | M} model - The model to be rendered\n   */\n  private refresh(model: string | M) {\n    model =\n      typeof model === 'string'\n        ? (Model.build({}, model) as M)\n        : model;\n    this.output = (model as unknown as Renderable).render<AngularDynamicOutput>(\n      this.globals || {},\n      this.vcr,\n      this.injector,\n      this.inner,\n    );\n    if (this.output?.inputs)\n      this.rendererId = sf(\n        AngularEngineKeys.RENDERED_ID,\n        (this.output.inputs as Record<string, unknown>)['rendererId'] as string,\n      );\n    this.instance = this.output?.instance;\n    this.subscribeEvents();\n  }\n\n  /**\n   * @description Lifecycle hook that is called when data-bound properties of a directive change\n   * @param {SimpleChanges} changes - Object containing changes\n   */\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes[BaseComponentProps.MODEL]) {\n      const { currentValue } = changes[BaseComponentProps.MODEL];\n      this.refresh(currentValue);\n    }\n  }\n\n  /**\n   * @description Lifecycle hook that is called when a directive, pipe, or service is destroyed\n   * @return {Promise<void>}\n   */\n  async ngOnDestroy(): Promise<void> {\n    if (this.instance) {\n      this.unsubscribeEvents();\n      await NgxRenderingEngine2.destroy();\n    }\n    this.output = undefined;\n  }\n\n  private subscribeEvents(): void {\n    if (this.instance) {\n      const componentKeys = Object.keys(this.instance);\n      for (const key of componentKeys) {\n        const value = this.instance[key];\n        if (value instanceof EventEmitter)\n          (this.instance as KeyValue)[key].subscribe((event: Partial<BaseCustomEvent>) => {\n            this.listenEvent.emit({\n              component: this.output?.component.name || '',\n              name: key,\n              ...event,\n            } as RendererCustomEvent);\n          });\n      }\n    }\n  }\n\n  /**\n   * @description Unsubscribes from events emitted by the rendered component\n   */\n  private unsubscribeEvents(): void {\n    if (this.instance) {\n      const componentKeys = Object.keys(this.instance);\n      for (const key of componentKeys) {\n        const value = this.instance[key];\n        if (value instanceof EventEmitter)\n          this.instance[key].unsubscribe();\n      }\n    }\n  }\n\n  protected readonly JSON = JSON;\n}\n","  <ng-template #componentOuter></ng-template>\n  <ng-template #inner>\n    <div  [id]=\"rendererId || null\">\n      @for (child of output?.children; track child) {\n        @if(child?.children?.length) {\n          <ngx-decaf-component-renderer [parent]=\"child\" />\n        } @else {\n          <ng-container\n            #childComponents\n            *ngComponentOutlet=\"\n              child.component;\n              injector: child.injector;\n              inputs: child.inputs;\n              content:child.content;\n            \"\n          />\n        }\n      }\n    </div>\n  </ng-template>\n"]}

package/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"]}