ngx-bootstrap 7.1.1 → 8.0.0-RC.3

package/pagination/esm2020/pager.component.mjs

@@ -0,0 +1,256 @@
+import { ChangeDetectorRef, Component, ElementRef, EventEmitter, forwardRef, Input, Output } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { PaginationConfig } from './pagination.config';
+import * as i0 from "@angular/core";
+import * as i1 from "./pagination.config";
+import * as i2 from "@angular/common";
+export const PAGER_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => PagerComponent),
+    multi: true
+};
+export class PagerComponent {
+    constructor(elementRef, paginationConfig, changeDetection) {
+        this.elementRef = elementRef;
+        this.changeDetection = changeDetection;
+        /** if `true` aligns each link to the sides of pager */
+        this.align = false;
+        /** if false first and last buttons will be hidden */
+        this.boundaryLinks = false;
+        /** if false previous and next buttons will be hidden */
+        this.directionLinks = true;
+        // labels
+        /** first button text */
+        this.firstText = 'First';
+        /** previous button text */
+        this.previousText = '« Previous';
+        /** next button text */
+        this.nextText = 'Next »';
+        /** last button text */
+        this.lastText = 'Last';
+        /** if true current page will in the middle of pages list */
+        this.rotate = true;
+        // css
+        /** add class to <code><li\></code> */
+        this.pageBtnClass = '';
+        /** if true pagination component will be disabled */
+        this.disabled = false;
+        /** fired when total pages count changes, $event:number equals to total pages count */
+        this.numPages = new EventEmitter();
+        /** fired when page was changed, $event:{page, itemsPerPage} equals to
+         * object with current page index and number of items per page
+         */
+        this.pageChanged = new EventEmitter();
+        this.onChange = Function.prototype;
+        this.onTouched = Function.prototype;
+        this.classMap = '';
+        this.inited = false;
+        this._itemsPerPage = 15;
+        this._totalItems = 0;
+        this._totalPages = 0;
+        this._page = 1;
+        this.elementRef = elementRef;
+        if (!this.config) {
+            this.configureOptions(Object.assign({}, paginationConfig.main, paginationConfig.pager));
+        }
+    }
+    /** maximum number of items per page. If value less than 1 will display all items on one page */
+    get itemsPerPage() {
+        return this._itemsPerPage;
+    }
+    set itemsPerPage(v) {
+        this._itemsPerPage = v;
+        this.totalPages = this.calculateTotalPages();
+    }
+    /** total number of items in all pages */
+    get totalItems() {
+        return this._totalItems;
+    }
+    set totalItems(v) {
+        this._totalItems = v;
+        this.totalPages = this.calculateTotalPages();
+    }
+    get totalPages() {
+        return this._totalPages;
+    }
+    set totalPages(v) {
+        this._totalPages = v;
+        this.numPages.emit(v);
+        if (this.inited) {
+            this.selectPage(this.page);
+        }
+    }
+    get page() {
+        return this._page;
+    }
+    set page(value) {
+        const _previous = this._page;
+        this._page = value > this.totalPages ? this.totalPages : value || 1;
+        this.changeDetection.markForCheck();
+        if (_previous === this._page || typeof _previous === 'undefined') {
+            return;
+        }
+        this.pageChanged.emit({
+            page: this._page,
+            itemsPerPage: this.itemsPerPage
+        });
+    }
+    configureOptions(config) {
+        this.config = Object.assign({}, config);
+    }
+    ngOnInit() {
+        if (typeof window !== 'undefined') {
+            this.classMap = this.elementRef.nativeElement.getAttribute('class') || '';
+        }
+        // watch for maxSize
+        if (typeof this.maxSize === 'undefined') {
+            this.maxSize = this.config?.maxSize || 0;
+        }
+        if (typeof this.rotate === 'undefined') {
+            this.rotate = !!this.config?.rotate;
+        }
+        if (typeof this.boundaryLinks === 'undefined') {
+            this.boundaryLinks = !!this.config?.boundaryLinks;
+        }
+        if (typeof this.directionLinks === 'undefined') {
+            this.directionLinks = !!this.config?.directionLinks;
+        }
+        if (typeof this.pageBtnClass === 'undefined') {
+            this.pageBtnClass = this.config?.pageBtnClass || '';
+        }
+        // base class
+        if (typeof this.itemsPerPage === 'undefined') {
+            this.itemsPerPage = this.config?.itemsPerPage || 0;
+        }
+        this.totalPages = this.calculateTotalPages();
+        // this class
+        this.pages = this.getPages(this.page, this.totalPages);
+        this.inited = true;
+    }
+    writeValue(value) {
+        this.page = value;
+        this.pages = this.getPages(this.page, this.totalPages);
+    }
+    getText(key) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this[`${key}Text`] || this.config[`${key}Text`];
+    }
+    noPrevious() {
+        return this.page === 1;
+    }
+    noNext() {
+        return this.page === this.totalPages;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    selectPage(page, event) {
+        if (event) {
+            event.preventDefault();
+        }
+        if (!this.disabled) {
+            if (event && event.target) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const target = event.target;
+                target.blur();
+            }
+            this.writeValue(page);
+            this.onChange(this.page);
+        }
+    }
+    // Create page object used in template
+    makePage(num, text, active) {
+        return { text, number: num, active };
+    }
+    getPages(currentPage, totalPages) {
+        const pages = [];
+        // Default page limits
+        let startPage = 1;
+        let endPage = totalPages;
+        const isMaxSized = typeof this.maxSize !== 'undefined' && this.maxSize < totalPages;
+        // recompute if maxSize
+        if (isMaxSized && this.maxSize) {
+            if (this.rotate) {
+                // Current page is displayed in the middle of the visible ones
+                startPage = Math.max(currentPage - Math.floor(this.maxSize / 2), 1);
+                endPage = startPage + this.maxSize - 1;
+                // Adjust if limit is exceeded
+                if (endPage > totalPages) {
+                    endPage = totalPages;
+                    startPage = endPage - this.maxSize + 1;
+                }
+            }
+            else {
+                // Visible pages are paginated with maxSize
+                startPage =
+                    (Math.ceil(currentPage / this.maxSize) - 1) * this.maxSize + 1;
+                // Adjust last page if limit is exceeded
+                endPage = Math.min(startPage + this.maxSize - 1, totalPages);
+            }
+        }
+        // Add page number links
+        for (let num = startPage; num <= endPage; num++) {
+            const page = this.makePage(num, num.toString(), num === currentPage);
+            pages.push(page);
+        }
+        // Add links to move between page sets
+        if (isMaxSized && !this.rotate) {
+            if (startPage > 1) {
+                const previousPageSet = this.makePage(startPage - 1, '...', false);
+                pages.unshift(previousPageSet);
+            }
+            if (endPage < totalPages) {
+                const nextPageSet = this.makePage(endPage + 1, '...', false);
+                pages.push(nextPageSet);
+            }
+        }
+        return pages;
+    }
+    // base class
+    calculateTotalPages() {
+        const totalPages = this.itemsPerPage < 1
+            ? 1
+            : Math.ceil(this.totalItems / this.itemsPerPage);
+        return Math.max(totalPages || 0, 1);
+    }
+}
+PagerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: PagerComponent, deps: [{ token: i0.ElementRef }, { token: i1.PaginationConfig }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+PagerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: PagerComponent, selector: "pager", inputs: { align: "align", maxSize: "maxSize", boundaryLinks: "boundaryLinks", directionLinks: "directionLinks", firstText: "firstText", previousText: "previousText", nextText: "nextText", lastText: "lastText", rotate: "rotate", pageBtnClass: "pageBtnClass", disabled: "disabled", itemsPerPage: "itemsPerPage", totalItems: "totalItems" }, outputs: { numPages: "numPages", pageChanged: "pageChanged" }, providers: [PAGER_CONTROL_VALUE_ACCESSOR], ngImport: i0, template: "<ul class=\"pager\">\n  <li [class.disabled]=\"noPrevious()\" [class.previous]=\"align\"\n      [ngClass]=\"{'pull-left': align, 'float-left': align}\"\n      class=\"{{ pageBtnClass }}\">\n    <a href (click)=\"selectPage(page - 1, $event)\">{{ getText('previous') }}</a>\n  </li>\n  <li [class.disabled]=\"noNext()\" [class.next]=\"align\"\n      [ngClass]=\"{'pull-right': align, 'float-right': align}\"\n      class=\"{{ pageBtnClass }}\">\n    <a href (click)=\"selectPage(page + 1, $event)\">{{ getText('next') }}</a>\n  </li>\n</ul>\n", directives: [{ type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: PagerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pager', providers: [PAGER_CONTROL_VALUE_ACCESSOR], template: "<ul class=\"pager\">\n  <li [class.disabled]=\"noPrevious()\" [class.previous]=\"align\"\n      [ngClass]=\"{'pull-left': align, 'float-left': align}\"\n      class=\"{{ pageBtnClass }}\">\n    <a href (click)=\"selectPage(page - 1, $event)\">{{ getText('previous') }}</a>\n  </li>\n  <li [class.disabled]=\"noNext()\" [class.next]=\"align\"\n      [ngClass]=\"{'pull-right': align, 'float-right': align}\"\n      class=\"{{ pageBtnClass }}\">\n    <a href (click)=\"selectPage(page + 1, $event)\">{{ getText('next') }}</a>\n  </li>\n</ul>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.PaginationConfig }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { align: [{
+                type: Input
+            }], maxSize: [{
+                type: Input
+            }], boundaryLinks: [{
+                type: Input
+            }], directionLinks: [{
+                type: Input
+            }], firstText: [{
+                type: Input
+            }], previousText: [{
+                type: Input
+            }], nextText: [{
+                type: Input
+            }], lastText: [{
+                type: Input
+            }], rotate: [{
+                type: Input
+            }], pageBtnClass: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], numPages: [{
+                type: Output
+            }], pageChanged: [{
+                type: Output
+            }], itemsPerPage: [{
+                type: Input
+            }], totalItems: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pager.component.js","sourceRoot":"","sources":["../../../../src/pagination/pager.component.ts","../../../../src/pagination/pager.component.html"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,YAAY,EACZ,UAAU,EACV,KAAK,EAEL,MAAM,EAEP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAKzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;;;;AAEvD,MAAM,CAAC,MAAM,4BAA4B,GAAa;IACpD,OAAO,EAAE,iBAAiB;IAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC;IAC7C,KAAK,EAAE,IAAI;CACZ,CAAC;AAOF,MAAM,OAAO,cAAc;IAyCzB,YAAoB,UAAsB,EAC9B,gBAAkC,EAC1B,eAAkC;QAFlC,eAAU,GAAV,UAAU,CAAY;QAEtB,oBAAe,GAAf,eAAe,CAAmB;QAzCtD,uDAAuD;QAC9C,UAAK,GAAG,KAAK,CAAC;QAGvB,qDAAqD;QAC5C,kBAAa,GAAG,KAAK,CAAC;QAC/B,wDAAwD;QAC/C,mBAAc,GAAG,IAAI,CAAC;QAC/B,SAAS;QACT,wBAAwB;QACf,cAAS,GAAG,OAAO,CAAC;QAC7B,2BAA2B;QAClB,iBAAY,GAAG,YAAY,CAAC;QACrC,uBAAuB;QACd,aAAQ,GAAG,QAAQ,CAAC;QAC7B,uBAAuB;QACd,aAAQ,GAAG,MAAM,CAAC;QAC3B,4DAA4D;QACnD,WAAM,GAAG,IAAI,CAAC;QACvB,MAAM;QACN,sCAAsC;QAC7B,iBAAY,GAAG,EAAE,CAAC;QAE3B,oDAAoD;QAC3C,aAAQ,GAAG,KAAK,CAAC;QAE1B,sFAAsF;QAC5E,aAAQ,GAAG,IAAI,YAAY,EAAU,CAAC;QAChD;;WAEG;QAEH,gBAAW,GAAG,IAAI,YAAY,EAAoB,CAAC;QACnD,aAAQ,GAAG,QAAQ,CAAC,SAAS,CAAC;QAC9B,cAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;QAC/B,aAAQ,GAAG,EAAE,CAAC;QAEJ,WAAM,GAAG,KAAK,CAAC;QAaf,kBAAa,GAAG,EAAE,CAAC;QAanB,gBAAW,GAAG,CAAC,CAAC;QAahB,gBAAW,GAAG,CAAC,CAAC;QAchB,UAAK,GAAG,CAAC,CAAC;QAhDlB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAChB,IAAI,CAAC,gBAAgB,CACnB,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,CACjE,CAAC;SACH;IACH,CAAC;IAID,gGAAgG;IAChG,IACI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,IAAI,YAAY,CAAC,CAAS;QACxB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC/C,CAAC;IAID,yCAAyC;IACzC,IACI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,IAAI,UAAU,CAAC,CAAS;QACtB,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC/C,CAAC;IAID,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,IAAI,UAAU,CAAC,CAAS;QACtB,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,IAAI,CAAC,MAAM,EAAE;YACf,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC5B;IACH,CAAC;IAID,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,IAAI,IAAI,CAAC,KAAa;QACpB,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC;QAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;QACpE,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;QAEpC,IAAI,SAAS,KAAK,IAAI,CAAC,KAAK,IAAI,OAAO,SAAS,KAAK,WAAW,EAAE;YAChE,OAAO;SACR;QAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YACpB,IAAI,EAAE,IAAI,CAAC,KAAK;YAChB,YAAY,EAAE,IAAI,CAAC,YAAY;SAChC,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB,CAAC,MAA4B;QAC3C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED,QAAQ;QACN,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;YACjC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;SAC3E;QACD,oBAAoB;QACpB,IAAI,OAAO,IAAI,CAAC,OAAO,KAAK,WAAW,EAAE;YACvC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,CAAC;SAC1C;QAED,IAAI,OAAO,IAAI,CAAC,MAAM,KAAK,WAAW,EAAE;YACtC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;SACrC;QAED,IAAI,OAAO,IAAI,CAAC,aAAa,KAAK,WAAW,EAAE;YAC7C,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,aAAa,CAAC;SACnD;QAGD,IAAI,OAAO,IAAI,CAAC,cAAc,KAAK,WAAW,EAAE;YAC9C,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,cAAc,CAAC;SACrD;QAED,IAAI,OAAO,IAAI,CAAC,YAAY,KAAK,WAAW,EAAE;YAC5C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,EAAE,YAAY,IAAI,EAAE,CAAC;SACrD;QAED,aAAa;QACb,IAAI,OAAO,IAAI,CAAC,YAAY,KAAK,WAAW,EAAE;YAC5C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,EAAE,YAAY,IAAI,CAAC,CAAC;SACpD;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7C,aAAa;QACb,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;IACrB,CAAC;IAED,UAAU,CAAC,KAAa;QACtB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IACzD,CAAC;IAED,OAAO,CAAC,GAAW;QACjB,8DAA8D;QAC9D,OAAQ,IAAY,CAAC,GAAG,GAAG,MAAM,CAAC,IAAK,IAAY,CAAC,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC;IAC3E,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,UAAU,CAAC;IACvC,CAAC;IAED,gBAAgB,CAAC,EAAc;QAC7B,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,iBAAiB,CAAC,EAAc;QAC9B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAED,UAAU,CAAC,IAAY,EAAE,KAAa;QACpC,IAAI,KAAK,EAAE;YACT,KAAK,CAAC,cAAc,EAAE,CAAC;SACxB;QAED,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE;gBACzB,8DAA8D;gBAC9D,MAAM,MAAM,GAAQ,KAAK,CAAC,MAAM,CAAC;gBACjC,MAAM,CAAC,IAAI,EAAE,CAAC;aACf;YACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC1B;IACH,CAAC;IAED,sCAAsC;IAC5B,QAAQ,CAAC,GAAW,EACX,IAAY,EACZ,MAAe;QAChC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IACvC,CAAC;IAES,QAAQ,CAAC,WAAmB,EAAE,UAAkB;QACxD,MAAM,KAAK,GAAiB,EAAE,CAAC;QAE/B,sBAAsB;QACtB,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,IAAI,OAAO,GAAG,UAAU,CAAC;QACzB,MAAM,UAAU,GACd,OAAO,IAAI,CAAC,OAAO,KAAK,WAAW,IAAI,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC;QAEnE,uBAAuB;QACvB,IAAI,UAAU,IAAI,IAAI,CAAC,OAAO,EAAE;YAC9B,IAAI,IAAI,CAAC,MAAM,EAAE;gBACf,8DAA8D;gBAC9D,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACpE,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;gBAEvC,8BAA8B;gBAC9B,IAAI,OAAO,GAAG,UAAU,EAAE;oBACxB,OAAO,GAAG,UAAU,CAAC;oBACrB,SAAS,GAAG,OAAO,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;iBACxC;aACF;iBAAM;gBACL,2CAA2C;gBAC3C,SAAS;oBACP,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;gBAEjE,wCAAwC;gBACxC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,UAAU,CAAC,CAAC;aAC9D;SACF;QAED,wBAAwB;QACxB,KAAK,IAAI,GAAG,GAAG,SAAS,EAAE,GAAG,IAAI,OAAO,EAAE,GAAG,EAAE,EAAE;YAC/C,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,EAAE,GAAG,KAAK,WAAW,CAAC,CAAC;YACrE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAClB;QAED,sCAAsC;QACtC,IAAI,UAAU,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAC9B,IAAI,SAAS,GAAG,CAAC,EAAE;gBACjB,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;gBACnE,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;aAChC;YAED,IAAI,OAAO,GAAG,UAAU,EAAE;gBACxB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;gBAC7D,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aACzB;SACF;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,aAAa;IACH,mBAAmB;QAC3B,MAAM,UAAU,GACd,IAAI,CAAC,YAAY,GAAG,CAAC;YACnB,CAAC,CAAC,CAAC;YACH,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;QAErD,OAAO,IAAI,CAAC,GAAG,CAAC,UAAU,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;IACtC,CAAC;;2GAxQU,cAAc;+FAAd,cAAc,ibAFd,CAAC,4BAA4B,CAAC,0BC3B3C,+hBAYA;2FDiBa,cAAc;kBAL1B,SAAS;+BACE,OAAO,aAEN,CAAC,4BAA4B,CAAC;gKAKhC,KAAK;sBAAb,KAAK;gBAEG,OAAO;sBAAf,KAAK;gBAEG,aAAa;sBAArB,KAAK;gBAEG,cAAc;sBAAtB,KAAK;gBAGG,SAAS;sBAAjB,KAAK;gBAEG,YAAY;sBAApB,KAAK;gBAEG,QAAQ;sBAAhB,KAAK;gBAEG,QAAQ;sBAAhB,KAAK;gBAEG,MAAM;sBAAd,KAAK;gBAGG,YAAY;sBAApB,KAAK;gBAGG,QAAQ;sBAAhB,KAAK;gBAGI,QAAQ;sBAAjB,MAAM;gBAKP,WAAW;sBADV,MAAM;gBAuBH,YAAY;sBADf,KAAK;gBAcF,UAAU;sBADb,KAAK","sourcesContent":["import {\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Input,\n  OnInit,\n  Output,\n  Provider\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { ConfigModel, PagesModel } from './models';\n\nimport { PageChangedEvent } from './pagination.component';\nimport { PaginationConfig } from './pagination.config';\n\nexport const PAGER_CONTROL_VALUE_ACCESSOR: Provider = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => PagerComponent),\n  multi: true\n};\n\n@Component({\n  selector: 'pager',\n  templateUrl: './pager.component.html',\n  providers: [PAGER_CONTROL_VALUE_ACCESSOR]\n})\nexport class PagerComponent implements ControlValueAccessor, OnInit {\n  config?: Partial<ConfigModel>;\n  /** if `true` aligns each link to the sides of pager */\n  @Input() align = false;\n  /** limit number for page links in pager */\n  @Input() maxSize?: number;\n  /** if false first and last buttons will be hidden */\n  @Input() boundaryLinks = false;\n  /** if false previous and next buttons will be hidden */\n  @Input() directionLinks = true;\n  // labels\n  /** first button text */\n  @Input() firstText = 'First';\n  /** previous button text */\n  @Input() previousText = '« Previous';\n  /** next button text */\n  @Input() nextText = 'Next »';\n  /** last button text */\n  @Input() lastText = 'Last';\n  /** if true current page will in the middle of pages list */\n  @Input() rotate = true;\n  // css\n  /** add class to <code><li\\></code> */\n  @Input() pageBtnClass = '';\n\n  /** if true pagination component will be disabled */\n  @Input() disabled = false;\n\n  /** fired when total pages count changes, $event:number equals to total pages count */\n  @Output() numPages = new EventEmitter<number>();\n  /** fired when page was changed, $event:{page, itemsPerPage} equals to\n   * object with current page index and number of items per page\n   */\n  @Output()\n  pageChanged = new EventEmitter<PageChangedEvent>();\n  onChange = Function.prototype;\n  onTouched = Function.prototype;\n  classMap = '';\n  pages?: PagesModel[];\n  protected inited = false;\n\n  constructor(private elementRef: ElementRef,\n              paginationConfig: PaginationConfig,\n              private changeDetection: ChangeDetectorRef) {\n    this.elementRef = elementRef;\n    if (!this.config) {\n      this.configureOptions(\n        Object.assign({}, paginationConfig.main, paginationConfig.pager)\n      );\n    }\n  }\n\n  protected _itemsPerPage = 15;\n\n  /** maximum number of items per page. If value less than 1 will display all items on one page */\n  @Input()\n  get itemsPerPage(): number {\n    return this._itemsPerPage;\n  }\n\n  set itemsPerPage(v: number) {\n    this._itemsPerPage = v;\n    this.totalPages = this.calculateTotalPages();\n  }\n\n  protected _totalItems = 0;\n\n  /** total number of items in all pages */\n  @Input()\n  get totalItems(): number {\n    return this._totalItems;\n  }\n\n  set totalItems(v: number) {\n    this._totalItems = v;\n    this.totalPages = this.calculateTotalPages();\n  }\n\n  protected _totalPages = 0;\n\n  get totalPages(): number {\n    return this._totalPages;\n  }\n\n  set totalPages(v: number) {\n    this._totalPages = v;\n    this.numPages.emit(v);\n    if (this.inited) {\n      this.selectPage(this.page);\n    }\n  }\n\n  protected _page = 1;\n\n  get page(): number {\n    return this._page;\n  }\n\n  set page(value: number) {\n    const _previous = this._page;\n    this._page = value > this.totalPages ? this.totalPages : value || 1;\n    this.changeDetection.markForCheck();\n\n    if (_previous === this._page || typeof _previous === 'undefined') {\n      return;\n    }\n\n    this.pageChanged.emit({\n      page: this._page,\n      itemsPerPage: this.itemsPerPage\n    });\n  }\n\n  configureOptions(config: Partial<ConfigModel>): void {\n    this.config = Object.assign({}, config);\n  }\n\n  ngOnInit(): void {\n    if (typeof window !== 'undefined') {\n      this.classMap = this.elementRef.nativeElement.getAttribute('class') || '';\n    }\n    // watch for maxSize\n    if (typeof this.maxSize === 'undefined') {\n      this.maxSize = this.config?.maxSize || 0;\n    }\n\n    if (typeof this.rotate === 'undefined') {\n      this.rotate = !!this.config?.rotate;\n    }\n\n    if (typeof this.boundaryLinks === 'undefined') {\n      this.boundaryLinks = !!this.config?.boundaryLinks;\n    }\n\n\n    if (typeof this.directionLinks === 'undefined') {\n      this.directionLinks = !!this.config?.directionLinks;\n    }\n\n    if (typeof this.pageBtnClass === 'undefined') {\n      this.pageBtnClass = this.config?.pageBtnClass || '';\n    }\n\n    // base class\n    if (typeof this.itemsPerPage === 'undefined') {\n      this.itemsPerPage = this.config?.itemsPerPage || 0;\n    }\n\n    this.totalPages = this.calculateTotalPages();\n    // this class\n    this.pages = this.getPages(this.page, this.totalPages);\n    this.inited = true;\n  }\n\n  writeValue(value: number): void {\n    this.page = value;\n    this.pages = this.getPages(this.page, this.totalPages);\n  }\n\n  getText(key: string): string {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (this as any)[`${key}Text`] || (this as any).config[`${key}Text`];\n  }\n\n  noPrevious(): boolean {\n    return this.page === 1;\n  }\n\n  noNext(): boolean {\n    return this.page === this.totalPages;\n  }\n\n  registerOnChange(fn: () => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  selectPage(page: number, event?: Event): void {\n    if (event) {\n      event.preventDefault();\n    }\n\n    if (!this.disabled) {\n      if (event && event.target) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const target: any = event.target;\n        target.blur();\n      }\n      this.writeValue(page);\n      this.onChange(this.page);\n    }\n  }\n\n  // Create page object used in template\n  protected makePage(num: number,\n                     text: string,\n                     active: boolean): { number: number; text: string; active: boolean } {\n    return { text, number: num, active };\n  }\n\n  protected getPages(currentPage: number, totalPages: number): PagesModel[] {\n    const pages: PagesModel[] = [];\n\n    // Default page limits\n    let startPage = 1;\n    let endPage = totalPages;\n    const isMaxSized =\n      typeof this.maxSize !== 'undefined' && this.maxSize < totalPages;\n\n    // recompute if maxSize\n    if (isMaxSized && this.maxSize) {\n      if (this.rotate) {\n        // Current page is displayed in the middle of the visible ones\n        startPage = Math.max(currentPage - Math.floor(this.maxSize / 2), 1);\n        endPage = startPage + this.maxSize - 1;\n\n        // Adjust if limit is exceeded\n        if (endPage > totalPages) {\n          endPage = totalPages;\n          startPage = endPage - this.maxSize + 1;\n        }\n      } else {\n        // Visible pages are paginated with maxSize\n        startPage =\n          (Math.ceil(currentPage / this.maxSize) - 1) * this.maxSize + 1;\n\n        // Adjust last page if limit is exceeded\n        endPage = Math.min(startPage + this.maxSize - 1, totalPages);\n      }\n    }\n\n    // Add page number links\n    for (let num = startPage; num <= endPage; num++) {\n      const page = this.makePage(num, num.toString(), num === currentPage);\n      pages.push(page);\n    }\n\n    // Add links to move between page sets\n    if (isMaxSized && !this.rotate) {\n      if (startPage > 1) {\n        const previousPageSet = this.makePage(startPage - 1, '...', false);\n        pages.unshift(previousPageSet);\n      }\n\n      if (endPage < totalPages) {\n        const nextPageSet = this.makePage(endPage + 1, '...', false);\n        pages.push(nextPageSet);\n      }\n    }\n\n    return pages;\n  }\n\n  // base class\n  protected calculateTotalPages(): number {\n    const totalPages =\n      this.itemsPerPage < 1\n        ? 1\n        : Math.ceil(this.totalItems / this.itemsPerPage);\n\n    return Math.max(totalPages || 0, 1);\n  }\n}\n","<ul class=\"pager\">\n  <li [class.disabled]=\"noPrevious()\" [class.previous]=\"align\"\n      [ngClass]=\"{'pull-left': align, 'float-left': align}\"\n      class=\"{{ pageBtnClass }}\">\n    <a href (click)=\"selectPage(page - 1, $event)\">{{ getText('previous') }}</a>\n  </li>\n  <li [class.disabled]=\"noNext()\" [class.next]=\"align\"\n      [ngClass]=\"{'pull-right': align, 'float-right': align}\"\n      class=\"{{ pageBtnClass }}\">\n    <a href (click)=\"selectPage(page + 1, $event)\">{{ getText('next') }}</a>\n  </li>\n</ul>\n"]}

package/pagination/esm2020/pagination.component.mjs

@@ -0,0 +1,257 @@
+import { ChangeDetectorRef, Component, ElementRef, EventEmitter, forwardRef, Input, Output, TemplateRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { PaginationConfig } from './pagination.config';
+import * as i0 from "@angular/core";
+import * as i1 from "./pagination.config";
+import * as i2 from "@angular/common";
+export const PAGINATION_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => PaginationComponent),
+    multi: true
+};
+export class PaginationComponent {
+    constructor(elementRef, paginationConfig, changeDetection) {
+        this.elementRef = elementRef;
+        this.changeDetection = changeDetection;
+        /** if `true` aligns each link to the sides of pager */
+        this.align = true;
+        /** if false first and last buttons will be hidden */
+        this.boundaryLinks = false;
+        /** if false previous and next buttons will be hidden */
+        this.directionLinks = true;
+        /** if true current page will in the middle of pages list */
+        this.rotate = true;
+        // css
+        /** add class to <code><li\></code> */
+        this.pageBtnClass = '';
+        /** if true pagination component will be disabled */
+        this.disabled = false;
+        /** fired when total pages count changes, $event:number equals to total pages count */
+        this.numPages = new EventEmitter();
+        /** fired when page was changed, $event:{page, itemsPerPage} equals to object
+         * with current page index and number of items per page
+         */
+        this.pageChanged = new EventEmitter();
+        this.onChange = Function.prototype;
+        this.onTouched = Function.prototype;
+        this.classMap = '';
+        this.inited = false;
+        this._itemsPerPage = 10;
+        this._totalItems = 0;
+        this._totalPages = 0;
+        this._page = 1;
+        this.elementRef = elementRef;
+        if (!this.config) {
+            this.configureOptions(paginationConfig.main);
+        }
+    }
+    /** maximum number of items per page. If value less than 1 will display all items on one page */
+    get itemsPerPage() {
+        return this._itemsPerPage;
+    }
+    set itemsPerPage(v) {
+        this._itemsPerPage = v;
+        this.totalPages = this.calculateTotalPages();
+    }
+    /** total number of items in all pages */
+    get totalItems() {
+        return this._totalItems;
+    }
+    set totalItems(v) {
+        this._totalItems = v;
+        this.totalPages = this.calculateTotalPages();
+    }
+    get totalPages() {
+        return this._totalPages;
+    }
+    set totalPages(v) {
+        this._totalPages = v;
+        this.numPages.emit(v);
+        if (this.inited) {
+            this.selectPage(this.page);
+        }
+    }
+    get page() {
+        return this._page;
+    }
+    set page(value) {
+        const _previous = this._page;
+        this._page = value > this.totalPages ? this.totalPages : value || 1;
+        this.changeDetection.markForCheck();
+        if (_previous === this._page || typeof _previous === 'undefined') {
+            return;
+        }
+        this.pageChanged.emit({
+            page: this._page,
+            itemsPerPage: this.itemsPerPage
+        });
+    }
+    configureOptions(config) {
+        this.config = Object.assign({}, config);
+    }
+    ngOnInit() {
+        if (typeof window !== 'undefined') {
+            this.classMap = this.elementRef.nativeElement.getAttribute('class') || '';
+        }
+        // watch for maxSize
+        if (typeof this.maxSize === 'undefined') {
+            this.maxSize = this.config?.maxSize || 0;
+        }
+        if (typeof this.rotate === 'undefined') {
+            this.rotate = !!this.config?.rotate;
+        }
+        if (typeof this.boundaryLinks === 'undefined') {
+            this.boundaryLinks = !!this.config?.boundaryLinks;
+        }
+        if (typeof this.directionLinks === 'undefined') {
+            this.directionLinks = !!this.config?.directionLinks;
+        }
+        if (typeof this.pageBtnClass === 'undefined') {
+            this.pageBtnClass = this.config?.pageBtnClass || '';
+        }
+        // base class
+        if (typeof this.itemsPerPage === 'undefined') {
+            this.itemsPerPage = this.config?.itemsPerPage || 0;
+        }
+        this.totalPages = this.calculateTotalPages();
+        // this class
+        this.pages = this.getPages(this.page, this.totalPages);
+        this.inited = true;
+    }
+    writeValue(value) {
+        this.page = value;
+        this.pages = this.getPages(this.page, this.totalPages);
+    }
+    getText(key) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this[`${key}Text`] || this.config[`${key}Text`];
+    }
+    noPrevious() {
+        return this.page === 1;
+    }
+    noNext() {
+        return this.page === this.totalPages;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    selectPage(page, event) {
+        if (event) {
+            event.preventDefault();
+        }
+        if (!this.disabled) {
+            if (event && event.target) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const target = event.target;
+                target.blur();
+            }
+            this.writeValue(page);
+            this.onChange(this.page);
+        }
+    }
+    // Create page object used in template
+    makePage(num, text, active) {
+        return { text, number: num, active };
+    }
+    getPages(currentPage, totalPages) {
+        const pages = [];
+        // Default page limits
+        let startPage = 1;
+        let endPage = totalPages;
+        const isMaxSized = typeof this.maxSize !== 'undefined' && this.maxSize < totalPages;
+        // recompute if maxSize
+        if (isMaxSized && this.maxSize) {
+            if (this.rotate) {
+                // Current page is displayed in the middle of the visible ones
+                startPage = Math.max(currentPage - Math.floor(this.maxSize / 2), 1);
+                endPage = startPage + this.maxSize - 1;
+                // Adjust if limit is exceeded
+                if (endPage > totalPages) {
+                    endPage = totalPages;
+                    startPage = endPage - this.maxSize + 1;
+                }
+            }
+            else {
+                // Visible pages are paginated with maxSize
+                startPage =
+                    (Math.ceil(currentPage / this.maxSize) - 1) * this.maxSize + 1;
+                // Adjust last page if limit is exceeded
+                endPage = Math.min(startPage + this.maxSize - 1, totalPages);
+            }
+        }
+        // Add page number links
+        for (let num = startPage; num <= endPage; num++) {
+            const page = this.makePage(num, num.toString(), num === currentPage);
+            pages.push(page);
+        }
+        // Add links to move between page sets
+        if (isMaxSized && !this.rotate) {
+            if (startPage > 1) {
+                const previousPageSet = this.makePage(startPage - 1, '...', false);
+                pages.unshift(previousPageSet);
+            }
+            if (endPage < totalPages) {
+                const nextPageSet = this.makePage(endPage + 1, '...', false);
+                pages.push(nextPageSet);
+            }
+        }
+        return pages;
+    }
+    // base class
+    calculateTotalPages() {
+        const totalPages = this.itemsPerPage < 1
+            ? 1
+            : Math.ceil(this.totalItems / this.itemsPerPage);
+        return Math.max(totalPages || 0, 1);
+    }
+}
+PaginationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: PaginationComponent, deps: [{ token: i0.ElementRef }, { token: i1.PaginationConfig }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+PaginationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: PaginationComponent, selector: "pagination", inputs: { align: "align", maxSize: "maxSize", boundaryLinks: "boundaryLinks", directionLinks: "directionLinks", firstText: "firstText", previousText: "previousText", nextText: "nextText", lastText: "lastText", rotate: "rotate", pageBtnClass: "pageBtnClass", disabled: "disabled", customPageTemplate: "customPageTemplate", customNextTemplate: "customNextTemplate", customPreviousTemplate: "customPreviousTemplate", customFirstTemplate: "customFirstTemplate", customLastTemplate: "customLastTemplate", itemsPerPage: "itemsPerPage", totalItems: "totalItems" }, outputs: { numPages: "numPages", pageChanged: "pageChanged" }, providers: [PAGINATION_CONTROL_VALUE_ACCESSOR], ngImport: i0, template: "<ul class=\"pagination\" [ngClass]=\"classMap\">\n  <li class=\"pagination-first page-item\"\n      *ngIf=\"boundaryLinks\"\n      [class.disabled]=\"noPrevious() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(1, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customFirstTemplate || defaultFirstTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noPrevious() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li class=\"pagination-prev page-item\"\n      *ngIf=\"directionLinks\"\n      [class.disabled]=\"noPrevious() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(page - 1, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customPreviousTemplate || defaultPreviousTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noPrevious() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li *ngFor=\"let pg of pages\"\n      [class.active]=\"pg.active\"\n      [class.disabled]=\"disabled && !pg.active\"\n      class=\"pagination-page page-item\">\n    <a class=\"page-link\" href (click)=\"selectPage(pg.number, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customPageTemplate || defaultPageTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: disabled, $implicit: pg, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li class=\"pagination-next page-item\"\n      *ngIf=\"directionLinks\"\n      [class.disabled]=\"noNext() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(page + 1, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customNextTemplate || defaultNextTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noNext() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li class=\"pagination-last page-item\"\n      *ngIf=\"boundaryLinks\"\n      [class.disabled]=\"noNext() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(totalPages, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customLastTemplate || defaultLastTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noNext() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n</ul>\n\n<ng-template #defaultPageTemplate let-page>{{ page.text }}</ng-template>\n\n<ng-template #defaultNextTemplate>{{ getText('next') }}</ng-template>\n\n<ng-template #defaultPreviousTemplate>{{ getText('previous') }}</ng-template>\n\n<ng-template #defaultFirstTemplate>{{ getText('first') }}</ng-template>\n\n<ng-template #defaultLastTemplate>{{ getText('last') }}</ng-template>\n", directives: [{ type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: PaginationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pagination', providers: [PAGINATION_CONTROL_VALUE_ACCESSOR], template: "<ul class=\"pagination\" [ngClass]=\"classMap\">\n  <li class=\"pagination-first page-item\"\n      *ngIf=\"boundaryLinks\"\n      [class.disabled]=\"noPrevious() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(1, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customFirstTemplate || defaultFirstTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noPrevious() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li class=\"pagination-prev page-item\"\n      *ngIf=\"directionLinks\"\n      [class.disabled]=\"noPrevious() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(page - 1, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customPreviousTemplate || defaultPreviousTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noPrevious() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li *ngFor=\"let pg of pages\"\n      [class.active]=\"pg.active\"\n      [class.disabled]=\"disabled && !pg.active\"\n      class=\"pagination-page page-item\">\n    <a class=\"page-link\" href (click)=\"selectPage(pg.number, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customPageTemplate || defaultPageTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: disabled, $implicit: pg, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li class=\"pagination-next page-item\"\n      *ngIf=\"directionLinks\"\n      [class.disabled]=\"noNext() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(page + 1, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customNextTemplate || defaultNextTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noNext() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li class=\"pagination-last page-item\"\n      *ngIf=\"boundaryLinks\"\n      [class.disabled]=\"noNext() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(totalPages, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customLastTemplate || defaultLastTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noNext() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n</ul>\n\n<ng-template #defaultPageTemplate let-page>{{ page.text }}</ng-template>\n\n<ng-template #defaultNextTemplate>{{ getText('next') }}</ng-template>\n\n<ng-template #defaultPreviousTemplate>{{ getText('previous') }}</ng-template>\n\n<ng-template #defaultFirstTemplate>{{ getText('first') }}</ng-template>\n\n<ng-template #defaultLastTemplate>{{ getText('last') }}</ng-template>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.PaginationConfig }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { align: [{
+                type: Input
+            }], maxSize: [{
+                type: Input
+            }], boundaryLinks: [{
+                type: Input
+            }], directionLinks: [{
+                type: Input
+            }], firstText: [{
+                type: Input
+            }], previousText: [{
+                type: Input
+            }], nextText: [{
+                type: Input
+            }], lastText: [{
+                type: Input
+            }], rotate: [{
+                type: Input
+            }], pageBtnClass: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], customPageTemplate: [{
+                type: Input
+            }], customNextTemplate: [{
+                type: Input
+            }], customPreviousTemplate: [{
+                type: Input
+            }], customFirstTemplate: [{
+                type: Input
+            }], customLastTemplate: [{
+                type: Input
+            }], numPages: [{
+                type: Output
+            }], pageChanged: [{
+                type: Output
+            }], itemsPerPage: [{
+                type: Input
+            }], totalItems: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.component.js","sourceRoot":"","sources":["../../../../src/pagination/pagination.component.ts","../../../../src/pagination/pagination.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Input,\n  OnInit,\n  Output,\n  Provider,\n  TemplateRef\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { ConfigModel, PagesModel, PaginationLinkContext, PaginationNumberLinkContext } from './models';\n\nimport { PaginationConfig } from './pagination.config';\n\nexport interface PageChangedEvent {\n  itemsPerPage: number;\n  page: number;\n}\n\nexport const PAGINATION_CONTROL_VALUE_ACCESSOR: Provider = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => PaginationComponent),\n  multi: true\n};\n\n@Component({\n  selector: 'pagination',\n  templateUrl: './pagination.component.html',\n  providers: [PAGINATION_CONTROL_VALUE_ACCESSOR]\n})\nexport class PaginationComponent implements ControlValueAccessor, OnInit {\n  config?: Partial<ConfigModel>;\n  /** if `true` aligns each link to the sides of pager */\n  @Input() align = true;\n  /** limit number for page links in pager */\n  @Input() maxSize?: number;\n  /** if false first and last buttons will be hidden */\n  @Input() boundaryLinks = false;\n  /** if false previous and next buttons will be hidden */\n  @Input() directionLinks = true;\n  // labels\n  /** first button text */\n  @Input() firstText?: string;\n  /** previous button text */\n  @Input() previousText?: string;\n  /** next button text */\n  @Input() nextText?: string;\n  /** last button text */\n  @Input() lastText?: string;\n  /** if true current page will in the middle of pages list */\n  @Input() rotate = true;\n  // css\n  /** add class to <code><li\\></code> */\n  @Input() pageBtnClass = '';\n  /** if true pagination component will be disabled */\n  @Input() disabled = false;\n  /** custom template for page link */\n  @Input() customPageTemplate?: TemplateRef<PaginationNumberLinkContext>;\n  /** custom template for next link */\n  @Input() customNextTemplate?: TemplateRef<PaginationLinkContext>;\n  /** custom template for previous link */\n  @Input() customPreviousTemplate?: TemplateRef<PaginationLinkContext>;\n  /** custom template for first link */\n  @Input() customFirstTemplate?: TemplateRef<PaginationLinkContext>;\n  /** custom template for last link */\n  @Input() customLastTemplate?: TemplateRef<PaginationLinkContext>;\n\n  /** fired when total pages count changes, $event:number equals to total pages count */\n  @Output() numPages = new EventEmitter<number>();\n  /** fired when page was changed, $event:{page, itemsPerPage} equals to object\n   * with current page index and number of items per page\n   */\n  @Output() pageChanged = new EventEmitter<PageChangedEvent>();\n  onChange = Function.prototype;\n  onTouched = Function.prototype;\n  classMap = '';\n  pages?: PagesModel[];\n  protected inited = false;\n\n  constructor(\n    private elementRef: ElementRef,\n    paginationConfig: PaginationConfig,\n    private changeDetection: ChangeDetectorRef\n  ) {\n    this.elementRef = elementRef;\n    if (!this.config) {\n      this.configureOptions(paginationConfig.main);\n    }\n  }\n\n  protected _itemsPerPage = 10;\n\n  /** maximum number of items per page. If value less than 1 will display all items on one page */\n  @Input()\n  get itemsPerPage(): number {\n    return this._itemsPerPage;\n  }\n\n  set itemsPerPage(v: number) {\n    this._itemsPerPage = v;\n    this.totalPages = this.calculateTotalPages();\n  }\n\n  protected _totalItems = 0;\n\n  /** total number of items in all pages */\n  @Input()\n  get totalItems(): number {\n    return this._totalItems;\n  }\n\n  set totalItems(v: number) {\n    this._totalItems = v;\n    this.totalPages = this.calculateTotalPages();\n  }\n\n  protected _totalPages = 0;\n\n  get totalPages(): number {\n    return this._totalPages;\n  }\n\n  set totalPages(v: number) {\n    this._totalPages = v;\n    this.numPages.emit(v);\n    if (this.inited) {\n      this.selectPage(this.page);\n    }\n  }\n\n  protected _page = 1;\n\n  get page(): number {\n    return this._page;\n  }\n\n  set page(value: number) {\n    const _previous = this._page;\n    this._page = value > this.totalPages ? this.totalPages : value || 1;\n    this.changeDetection.markForCheck();\n\n    if (_previous === this._page || typeof _previous === 'undefined') {\n      return;\n    }\n\n    this.pageChanged.emit({\n      page: this._page,\n      itemsPerPage: this.itemsPerPage\n    });\n  }\n\n  configureOptions(config: Partial<ConfigModel>): void {\n    this.config = Object.assign({}, config);\n  }\n\n  ngOnInit(): void {\n    if (typeof window !== 'undefined') {\n      this.classMap = this.elementRef.nativeElement.getAttribute('class') || '';\n    }\n\n    // watch for maxSize\n    if (typeof this.maxSize === 'undefined') {\n      this.maxSize = this.config?.maxSize || 0;\n    }\n\n    if (typeof this.rotate === 'undefined') {\n      this.rotate = !!this.config?.rotate;\n    }\n\n    if (typeof this.boundaryLinks === 'undefined') {\n      this.boundaryLinks = !!this.config?.boundaryLinks;\n    }\n\n\n    if (typeof this.directionLinks === 'undefined') {\n      this.directionLinks = !!this.config?.directionLinks;\n    }\n\n    if (typeof this.pageBtnClass === 'undefined') {\n      this.pageBtnClass = this.config?.pageBtnClass || '';\n    }\n\n    // base class\n    if (typeof this.itemsPerPage === 'undefined') {\n      this.itemsPerPage = this.config?.itemsPerPage || 0;\n    }\n\n    this.totalPages = this.calculateTotalPages();\n    // this class\n    this.pages = this.getPages(this.page, this.totalPages);\n    this.inited = true;\n  }\n\n  writeValue(value: number): void {\n    this.page = value;\n    this.pages = this.getPages(this.page, this.totalPages);\n  }\n\n  getText(key: string): string {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (this as any)[`${key}Text`] || (this as any).config[`${key}Text`];\n  }\n\n  noPrevious(): boolean {\n    return this.page === 1;\n  }\n\n  noNext(): boolean {\n    return this.page === this.totalPages;\n  }\n\n  registerOnChange(fn: () => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  selectPage(page: number, event?: Event): void {\n    if (event) {\n      event.preventDefault();\n    }\n\n    if (!this.disabled) {\n      if (event && event.target) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const target: any = event.target;\n        target.blur();\n      }\n      this.writeValue(page);\n      this.onChange(this.page);\n    }\n  }\n\n  // Create page object used in template\n  protected makePage(\n    num: number,\n    text: string,\n    active: boolean\n  ): { number: number; text: string; active: boolean } {\n    return { text, number: num, active };\n  }\n\n  protected getPages(currentPage: number, totalPages: number): PagesModel[] {\n    const pages: PagesModel[] = [];\n\n    // Default page limits\n    let startPage = 1;\n    let endPage = totalPages;\n    const isMaxSized =\n      typeof this.maxSize !== 'undefined' && this.maxSize < totalPages;\n\n    // recompute if maxSize\n    if (isMaxSized && this.maxSize) {\n      if (this.rotate) {\n        // Current page is displayed in the middle of the visible ones\n        startPage = Math.max(currentPage - Math.floor(this.maxSize / 2), 1);\n        endPage = startPage + this.maxSize - 1;\n\n        // Adjust if limit is exceeded\n        if (endPage > totalPages) {\n          endPage = totalPages;\n          startPage = endPage - this.maxSize + 1;\n        }\n      } else {\n        // Visible pages are paginated with maxSize\n        startPage =\n          (Math.ceil(currentPage / this.maxSize) - 1) * this.maxSize + 1;\n\n        // Adjust last page if limit is exceeded\n        endPage = Math.min(startPage + this.maxSize - 1, totalPages);\n      }\n    }\n\n    // Add page number links\n    for (let num = startPage; num <= endPage; num++) {\n      const page = this.makePage(num, num.toString(), num === currentPage);\n      pages.push(page);\n    }\n\n    // Add links to move between page sets\n    if (isMaxSized && !this.rotate) {\n      if (startPage > 1) {\n        const previousPageSet = this.makePage(startPage - 1, '...', false);\n        pages.unshift(previousPageSet);\n      }\n\n      if (endPage < totalPages) {\n        const nextPageSet = this.makePage(endPage + 1, '...', false);\n        pages.push(nextPageSet);\n      }\n    }\n\n    return pages;\n  }\n\n  // base class\n  protected calculateTotalPages(): number {\n    const totalPages =\n      this.itemsPerPage < 1\n        ? 1\n        : Math.ceil(this.totalItems / this.itemsPerPage);\n\n    return Math.max(totalPages || 0, 1);\n  }\n}\n","<ul class=\"pagination\" [ngClass]=\"classMap\">\n  <li class=\"pagination-first page-item\"\n      *ngIf=\"boundaryLinks\"\n      [class.disabled]=\"noPrevious() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(1, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customFirstTemplate || defaultFirstTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noPrevious() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li class=\"pagination-prev page-item\"\n      *ngIf=\"directionLinks\"\n      [class.disabled]=\"noPrevious() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(page - 1, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customPreviousTemplate || defaultPreviousTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noPrevious() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li *ngFor=\"let pg of pages\"\n      [class.active]=\"pg.active\"\n      [class.disabled]=\"disabled && !pg.active\"\n      class=\"pagination-page page-item\">\n    <a class=\"page-link\" href (click)=\"selectPage(pg.number, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customPageTemplate || defaultPageTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: disabled, $implicit: pg, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li class=\"pagination-next page-item\"\n      *ngIf=\"directionLinks\"\n      [class.disabled]=\"noNext() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(page + 1, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customNextTemplate || defaultNextTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noNext() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n\n  <li class=\"pagination-last page-item\"\n      *ngIf=\"boundaryLinks\"\n      [class.disabled]=\"noNext() || disabled\">\n    <a class=\"page-link\" href (click)=\"selectPage(totalPages, $event)\">\n      <ng-container [ngTemplateOutlet]=\"customLastTemplate || defaultLastTemplate\"\n                   [ngTemplateOutletContext]=\"{disabled: noNext() || disabled, currentPage: page}\">\n      </ng-container>\n    </a>\n  </li>\n</ul>\n\n<ng-template #defaultPageTemplate let-page>{{ page.text }}</ng-template>\n\n<ng-template #defaultNextTemplate>{{ getText('next') }}</ng-template>\n\n<ng-template #defaultPreviousTemplate>{{ getText('previous') }}</ng-template>\n\n<ng-template #defaultFirstTemplate>{{ getText('first') }}</ng-template>\n\n<ng-template #defaultLastTemplate>{{ getText('last') }}</ng-template>\n"]}