@gipisistemas/ng-core 1.0.67 → 1.0.68

package/esm5/shared/gipi-components/table/components/table-footer/table-footer.component.js

@@ -0,0 +1,33 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, Component, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+var GIPITableFooterComponent = /** @class */ (function () {
+    function GIPITableFooterComponent() {
+    }
+    GIPITableFooterComponent_1 = GIPITableFooterComponent;
+    GIPITableFooterComponent.prototype.ngOnInit = function () { };
+    var GIPITableFooterComponent_1;
+    GIPITableFooterComponent = GIPITableFooterComponent_1 = __decorate([
+        Component({
+            selector: "gipi-table-footer",
+            exportAs: 'gipiTableFooter',
+            template: "<p>\n  table-footer works!\n</p>\n",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return GIPITableFooterComponent_1; }),
+                    multi: true
+                }
+            ],
+            host: {
+                'class': 'gipi-table-footer',
+            },
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            styles: [""]
+        }),
+        __metadata("design:paramtypes", [])
+    ], GIPITableFooterComponent);
+    return GIPITableFooterComponent;
+}());
+export { GIPITableFooterComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/shared/gipi-components/table/components/table-header/table-header.component.js

@@ -0,0 +1,155 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, OnInit, Output, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { ObjectUtil } from '../../../../../core/utils/object.util';
+import { SortModel } from '../../models/sort.model';
+var GIPITableHeaderComponent = /** @class */ (function () {
+    function GIPITableHeaderComponent(_changeDetectorRef) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._sortedColumn = null;
+        this.columns = [];
+        this.loading = false;
+        this.disabled = false;
+        this.sortStart = 'asc';
+        this.sortDisableClear = true;
+        this.sortLocked = false;
+        this.sortAscendingIcon = 'keyboard_arrow_up';
+        this.sortDescendingIcon = 'keyboard_arrow_down';
+        this.sortUnsetIcon = 'unfold_more';
+        this.sortChange = new EventEmitter();
+    }
+    GIPITableHeaderComponent_1 = GIPITableHeaderComponent;
+    GIPITableHeaderComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        if ((this.columns && this.columns.length) && this.sortActive) {
+            var columnActive = this.columns.find(function (c) { return c.property === _this.sortActive; });
+            if (!ObjectUtil.isNull(columnActive) && columnActive.sortable && ObjectUtil.isNull(this._sortedColumn)) {
+                this._sortedColumn = {};
+                this._sortedColumn.column = columnActive;
+                this._sortedColumn.sortDirection = this.sortStart;
+                this.sortChange.emit(new SortModel(columnActive.property, this._sortedColumn.sortDirection));
+            }
+            else {
+                throw new Error('There is no column with the property indicated in "sortActive"');
+            }
+        }
+    };
+    GIPITableHeaderComponent.prototype.columnTrackingFn = function (index, column) {
+        return column.property;
+    };
+    GIPITableHeaderComponent.prototype.onSortChange = function (column) {
+        if (!column.sortable || this.sortLocked) {
+            return;
+        }
+        if (ObjectUtil.isNull(this._sortedColumn)) {
+            this._sortedColumn = {};
+        }
+        this._sortedColumn.column = column;
+        this._sortedColumn.sortDirection = this._getNextSortDirection(column);
+        this.sortChange.emit(new SortModel(column.property, this._sortedColumn.sortDirection));
+        this._changeDetectorRef.markForCheck();
+    };
+    GIPITableHeaderComponent.prototype._getNextSortDirection = function (column) {
+        if (!column.sortable) {
+            return '';
+        }
+        if (this.sortDisableClear) {
+            if (this._sortedColumn.sortDirection === 'asc') {
+                return 'desc';
+            }
+            else {
+                return 'asc';
+            }
+        }
+        else {
+            if (!this._sortedColumn.sortDirection) {
+                return 'asc';
+            }
+            else if (this._sortedColumn.sortDirection === 'asc') {
+                return 'desc';
+            }
+            else if (this._sortedColumn.sortDirection === 'desc') {
+                return '';
+            }
+        }
+        return '';
+    };
+    GIPITableHeaderComponent.prototype.isEqualsColumns = function (column) {
+        if (!ObjectUtil.isNull(this._sortedColumn) && !ObjectUtil.isNull(this._sortedColumn.column)) {
+            var equals = ObjectUtil.shallowEqual(this._sortedColumn.column, column);
+            return equals;
+        }
+        return false;
+    };
+    var GIPITableHeaderComponent_1;
+    GIPITableHeaderComponent.ctorParameters = function () { return [
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Array)
+    ], GIPITableHeaderComponent.prototype, "columns", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPITableHeaderComponent.prototype, "loading", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPITableHeaderComponent.prototype, "disabled", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITableHeaderComponent.prototype, "sortActive", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITableHeaderComponent.prototype, "sortStart", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPITableHeaderComponent.prototype, "sortDisableClear", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPITableHeaderComponent.prototype, "sortLocked", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITableHeaderComponent.prototype, "sortAscendingIcon", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITableHeaderComponent.prototype, "sortDescendingIcon", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITableHeaderComponent.prototype, "sortUnsetIcon", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPITableHeaderComponent.prototype, "sortChange", void 0);
+    GIPITableHeaderComponent = GIPITableHeaderComponent_1 = __decorate([
+        Component({
+            selector: "gipi-table-header",
+            exportAs: 'gipiTableHeader',
+            template: "<div class=\"table-header-content\"\n     role=\"rowheader\"\n     #contentHeader\n     gipi-row>\n\n    <div *ngFor=\"let column of columns; trackBy: columnTrackingFn; let i = index;\"\n         class=\"table-header-cell noselect\"\n         role=\"cell\"\n         gipi-col\n         [GIPISpan]=\"column.columnSpan\"\n         [attr.id]=\"column.property\"\n         [style.align-items]=\"'center'\"\n         [style.padding-inline.px]=\"column.paddingInline\"\n         [style.justify-content]=\"column.align\"\n         [style.cursor]=\"column.sortable && !sortLocked ? 'pointer' : 'default'\"\n         (click)=\"onSortChange(column)\">\n        <span class=\"table-header-label\"\n              *ngIf=\"column.name\">\n            {{ column.name }}\n        </span>\n\n        <ng-container *ngIf=\"column.sortable && _sortedColumn && (column.property === _sortedColumn?.column?.property)\">\n            <mat-icon *ngIf=\"(_sortedColumn?.sortDirection === 'asc')\"\n                      class=\"table-header-sort\">\n                {{ sortAscendingIcon }}\n            </mat-icon>\n            <mat-icon *ngIf=\"(_sortedColumn?.sortDirection === 'desc')\"\n                      class=\"table-header-sort\">\n                {{ sortDescendingIcon }}\n            </mat-icon>\n            <mat-icon *ngIf=\"(_sortedColumn?.sortDirection === '')\"\n                      class=\"table-header-sort\">\n                {{ sortUnsetIcon }}\n            </mat-icon>\n        </ng-container>\n    </div>\n\n</div>",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return GIPITableHeaderComponent_1; }),
+                    multi: true
+                }
+            ],
+            host: {
+                'class': 'gipi-table-header',
+            },
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            styles: [".table-header-content{position:relative;white-space:nowrap;border-bottom:1px solid #e0e1e2;overflow:hidden;text-overflow:ellipsis;font-weight:600;font-size:1.4rem;line-height:100%;color:#131313}.table-header-content .table-header-cell{padding:2.4rem 0;gap:1.6rem;display:flex}.table-header-content .table-header-sort{color:#131313;fill:#131313;width:1.4rem;height:1.4rem;font-size:1.4rem}.table-header-label{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}"]
+        }),
+        __metadata("design:paramtypes", [ChangeDetectorRef])
+    ], GIPITableHeaderComponent);
+    return GIPITableHeaderComponent;
+}());
+export { GIPITableHeaderComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-header.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/table/components/table-header/table-header.component.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACvI,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAqBpD;IAqBI,kCAAoB,kBAAqC;QAArC,uBAAkB,GAAlB,kBAAkB,CAAmB;QAnBzD,kBAAa,GAAiE,IAAI,CAAC;QAE1E,YAAO,GAAuB,EAAE,CAAC;QAEjC,YAAO,GAAY,KAAK,CAAC;QAEzB,aAAQ,GAAY,KAAK,CAAC;QAG1B,cAAS,GAAmB,KAAK,CAAC;QAClC,qBAAgB,GAAY,IAAI,CAAC;QACjC,eAAU,GAAY,KAAK,CAAC;QAE5B,sBAAiB,GAAW,mBAAmB,CAAC;QAChD,uBAAkB,GAAW,qBAAqB,CAAC;QACnD,kBAAa,GAAW,aAAa,CAAC;QAErC,eAAU,GAA4B,IAAI,YAAY,EAAa,CAAC;IAEjB,CAAC;iCArBrD,wBAAwB;IAuBjC,2CAAQ,GAAR;QAAA,iBAYC;QAXG,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE;YAC1D,IAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,QAAQ,KAAK,KAAI,CAAC,UAAU,EAA9B,CAA8B,CAAC,CAAC;YAC5E,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,YAAY,CAAC,QAAQ,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE;gBACpG,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;gBACxB,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,YAAY,CAAC;gBACzC,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC;gBAClD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;aAChG;iBAAM;gBACH,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;aACrF;SACJ;IACL,CAAC;IAEM,mDAAgB,GAAvB,UAAwB,KAAa,EAAE,MAAwB;QAC3D,OAAO,MAAM,CAAC,QAAQ,CAAC;IAC3B,CAAC;IAEM,+CAAY,GAAnB,UAAoB,MAAwB;QACxC,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE;YACrC,OAAO;SACV;QAED,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE;YACvC,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;SAC3B;QAED,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC;QACnC,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QACtE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;QAEvF,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;IAC3C,CAAC;IAEO,wDAAqB,GAA7B,UAA8B,MAAwB;QAClD,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE;YAClB,OAAO,EAAE,CAAC;SACb;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACvB,IAAI,IAAI,CAAC,aAAa,CAAC,aAAa,KAAK,KAAK,EAAE;gBAC5C,OAAO,MAAM,CAAC;aACjB;iBAAM;gBACH,OAAO,KAAK,CAAC;aAChB;SACJ;aAAM;YACH,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE;gBACnC,OAAO,KAAK,CAAC;aAChB;iBAAM,IAAI,IAAI,CAAC,aAAa,CAAC,aAAa,KAAK,KAAK,EAAE;gBACnD,OAAO,MAAM,CAAC;aACjB;iBAAM,IAAI,IAAI,CAAC,aAAa,CAAC,aAAa,KAAK,MAAM,EAAE;gBACpD,OAAO,EAAE,CAAC;aACb;SACJ;QAED,OAAO,EAAE,CAAC;IACd,CAAC;IAEM,kDAAe,GAAtB,UAAuB,MAAwB;QAC3C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE;YACzF,IAAM,MAAM,GAAY,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YACnF,OAAO,MAAM,CAAC;SACjB;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;;;gBAnEuC,iBAAiB;;IAjBhD;QAAR,KAAK,EAAE;;6DAAkC;IAEjC;QAAR,KAAK,EAAE;;6DAA0B;IAEzB;QAAR,KAAK,EAAE;;8DAA2B;IAE1B;QAAR,KAAK,EAAE;;gEAAoB;IACnB;QAAR,KAAK,EAAE;;+DAAmC;IAClC;QAAR,KAAK,EAAE;;sEAAkC;IACjC;QAAR,KAAK,EAAE;;gEAA6B;IAE5B;QAAR,KAAK,EAAE;;uEAAiD;IAChD;QAAR,KAAK,EAAE;;wEAAoD;IACnD;QAAR,KAAK,EAAE;;mEAAuC;IAErC;QAAT,MAAM,EAAE;kCAAa,YAAY;gEAA4C;IAnBrE,wBAAwB;QAjBpC,SAAS,CAAC;YACP,QAAQ,EAAE,mBAAmB;YAC7B,QAAQ,EAAE,iBAAiB;YAC3B,u/CAA4C;YAE5C,SAAS,EAAE;gBACP;oBACI,OAAO,EAAE,iBAAiB;oBAC1B,WAAW,EAAE,UAAU,CAAC,cAAuC,OAAA,0BAAwB,EAAxB,CAAwB,CAAC;oBACxF,KAAK,EAAE,IAAI;iBACd;aACJ;YACD,IAAI,EAAE;gBACF,OAAO,EAAE,mBAAmB;aAC/B;YACD,eAAe,EAAE,uBAAuB,CAAC,MAAM;;SAClD,CAAC;yCAsB0C,iBAAiB;OArBhD,wBAAwB,CA0FpC;IAAD,+BAAC;CAAA,AA1FD,IA0FC;SA1FY,wBAAwB","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, OnInit, Output, forwardRef } from '@angular/core';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { ObjectUtil } from '../../../../../core/utils/object.util';\nimport { SortModel } from '../../models/sort.model';\nimport { TableColumnModel } from '../../models/table-column.model';\nimport { SortDirection } from '../../types/sort-direction.type';\n\n@Component({\n    selector: `gipi-table-header`,\n    exportAs: 'gipiTableHeader',\n    templateUrl: './table-header.component.html',\n    styleUrls: ['./table-header.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof GIPITableHeaderComponent => GIPITableHeaderComponent),\n            multi: true\n        }\n    ],\n    host: {\n        'class': 'gipi-table-header',\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class GIPITableHeaderComponent implements OnInit {\n\n    _sortedColumn: { column?: TableColumnModel, sortDirection?: SortDirection } = null;\n\n    @Input() columns: TableColumnModel[] = [];\n\n    @Input() loading: boolean = false;\n\n    @Input() disabled: boolean = false;\n\n    @Input() sortActive: string;\n    @Input() sortStart: 'asc' | 'desc' = 'asc';\n    @Input() sortDisableClear: boolean = true;\n    @Input() sortLocked: boolean = false;\n\n    @Input() sortAscendingIcon: string = 'keyboard_arrow_up';\n    @Input() sortDescendingIcon: string = 'keyboard_arrow_down';\n    @Input() sortUnsetIcon: string = 'unfold_more';\n\n    @Output() sortChange: EventEmitter<SortModel> = new EventEmitter<SortModel>();\n\n    constructor(private _changeDetectorRef: ChangeDetectorRef) { }\n\n    ngOnInit() {\n        if ((this.columns && this.columns.length) && this.sortActive) {\n            const columnActive = this.columns.find(c => c.property === this.sortActive);\n            if (!ObjectUtil.isNull(columnActive) && columnActive.sortable && ObjectUtil.isNull(this._sortedColumn)) {\n                this._sortedColumn = {};\n                this._sortedColumn.column = columnActive;\n                this._sortedColumn.sortDirection = this.sortStart;\n                this.sortChange.emit(new SortModel(columnActive.property, this._sortedColumn.sortDirection));\n            } else {\n                throw new Error('There is no column with the property indicated in \"sortActive\"');\n            }\n        }\n    }\n\n    public columnTrackingFn(index: number, column: TableColumnModel): any {\n        return column.property;\n    }\n\n    public onSortChange(column: TableColumnModel): void {\n        if (!column.sortable || this.sortLocked) {\n            return;\n        }\n\n        if (ObjectUtil.isNull(this._sortedColumn)) {\n            this._sortedColumn = {};\n        }\n\n        this._sortedColumn.column = column;\n        this._sortedColumn.sortDirection = this._getNextSortDirection(column);\n        this.sortChange.emit(new SortModel(column.property, this._sortedColumn.sortDirection));\n\n        this._changeDetectorRef.markForCheck();\n    }\n\n    private _getNextSortDirection(column: TableColumnModel): SortDirection {\n        if (!column.sortable) {\n            return '';\n        }\n\n        if (this.sortDisableClear) {\n            if (this._sortedColumn.sortDirection === 'asc') {\n                return 'desc';\n            } else {\n                return 'asc';\n            }\n        } else {\n            if (!this._sortedColumn.sortDirection) {\n                return 'asc';\n            } else if (this._sortedColumn.sortDirection === 'asc') {\n                return 'desc';\n            } else if (this._sortedColumn.sortDirection === 'desc') {\n                return '';\n            }\n        }\n\n        return '';\n    }\n\n    public isEqualsColumns(column: TableColumnModel): boolean {\n        if (!ObjectUtil.isNull(this._sortedColumn) && !ObjectUtil.isNull(this._sortedColumn.column)) {\n            const equals: boolean = ObjectUtil.shallowEqual(this._sortedColumn.column, column);\n            return equals;\n        }\n\n        return false;\n    }\n\n}\n"]}

package/esm5/shared/gipi-components/table/components/table-pagination/shared/paginate.pipe.js

@@ -0,0 +1,123 @@
+import { __decorate, __metadata } from "tslib";
+import { Pipe } from "@angular/core";
+import { GIPIPaginationService } from "./pagination.service";
+var LARGE_NUMBER = Number.MAX_SAFE_INTEGER;
+var GIPIPaginatePipe = /** @class */ (function () {
+    function GIPIPaginatePipe(_service) {
+        this._service = _service;
+        // Armazenar os valores da última vez que o pipe foi invocado
+        this._state = {};
+    }
+    GIPIPaginatePipe.prototype.transform = function (collection, args) {
+        // Quando um observável é passado pelo AsyncPipe, ele produzirá
+        // `null` até que a assinatura seja resolvida. Neste caso, queremos
+        // usar os dados em cache do objeto `_state` para evitar que o NgFor
+        // pisque vazio até que os valores reais cheguem.
+        if (!(collection instanceof Array)) {
+            var _id = args.id || this._service.defaultId();
+            if (this._state[_id]) {
+                return this._state[_id].slice;
+            }
+            else {
+                return collection;
+            }
+        }
+        var serverSideMode = args.totalItems && args.totalItems !== collection.length;
+        var instance = this.createInstance(collection, args);
+        var id = instance.id;
+        var start;
+        var end;
+        var perPage = instance.itemsPerPage;
+        var emitChange = this._service.register(instance);
+        if (!serverSideMode && collection instanceof Array) {
+            perPage = +perPage || LARGE_NUMBER;
+            start = (instance.currentPage - 1) * perPage;
+            end = start + perPage;
+            var isIdentical = this.stateIsIdentical(id, collection, start, end);
+            if (isIdentical) {
+                return this._state[id].slice;
+            }
+            else {
+                var slice = collection.slice(start, end);
+                this.saveState(id, collection, slice, start, end);
+                this._service.change.emit(id);
+                return slice;
+            }
+        }
+        else {
+            if (emitChange) {
+                this._service.change.emit(id);
+            }
+            // salve o estado para coleta do lado do servidor para evitar nulo
+            // pisca à medida que novos dados são carregados.
+            this.saveState(id, collection, collection, start, end);
+            return collection;
+        }
+    };
+    /**
+     * Crie um objeto PaginationInstance, usando padrões para quaisquer propriedades opcionais não fornecidas.
+     */
+    GIPIPaginatePipe.prototype.createInstance = function (collection, config) {
+        this.checkConfig(config);
+        return {
+            id: config.id != null ? config.id : this._service.defaultId(),
+            itemsPerPage: +config.itemsPerPage || 0,
+            currentPage: +config.currentPage || 1,
+            totalItems: +config.totalItems || collection.length
+        };
+    };
+    /**
+     * Assegure-se de que o argumento passado para o filtro contenha as propriedades necessárias.
+     */
+    GIPIPaginatePipe.prototype.checkConfig = function (config) {
+        var required = ['itemsPerPage', 'currentPage'];
+        var missing = required.filter(function (prop) { return !(prop in config); });
+        if (0 < missing.length) {
+            throw new Error("PaginatePipe: Argumento est\u00E1 faltando as seguintes propriedades necess\u00E1rias: " + missing.join(', '));
+        }
+    };
+    /**
+     * Para evitar o retorno de um novo array toda vez que o pipe é executado, armazenamos o estado do sliced
+     * array para um determinado id. Isso significa que na próxima vez que o canal for executado nesta coleção e id, apenas
+     * precisa verificar se a coleta, os pontos inicial e final são todos idênticos e, em caso afirmativo, retornar o
+     * último array fatiado.
+     */
+    GIPIPaginatePipe.prototype.saveState = function (id, collection, slice, start, end) {
+        this._state[id] = {
+            collection: collection,
+            size: collection.length,
+            slice: slice,
+            start: start,
+            end: end
+        };
+    };
+    /**
+     * Para um determinado id, retorna true se os valores de coleção, tamanho, início e fim forem idênticos.
+     */
+    GIPIPaginatePipe.prototype.stateIsIdentical = function (id, collection, start, end) {
+        var state = this._state[id];
+        if (!state) {
+            return false;
+        }
+        var isMetaDataIdentical = state.size === collection.length &&
+            state.start === start &&
+            state.end === end;
+        if (!isMetaDataIdentical) {
+            return false;
+        }
+        return state.slice.every(function (element, index) { return element === collection[start + index]; });
+    };
+    GIPIPaginatePipe.ctorParameters = function () { return [
+        { type: GIPIPaginationService }
+    ]; };
+    GIPIPaginatePipe = __decorate([
+        Pipe({
+            name: 'paginate',
+            pure: false
+        }),
+        __metadata("design:paramtypes", [GIPIPaginationService])
+    ], GIPIPaginatePipe);
+    return GIPIPaginatePipe;
+}());
+export { GIPIPaginatePipe };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paginate.pipe.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/table/components/table-pagination/shared/paginate.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Pipe } from \"@angular/core\";\nimport { PaginationInstance } from './pagination-instance';\nimport { GIPIPaginationService } from \"./pagination.service\";\n\nconst LARGE_NUMBER = Number.MAX_SAFE_INTEGER;\n\nexport type Collection<T> = T[] | ReadonlyArray<T>;\n\nexport interface PaginatePipeArgs {\n    id?: string;\n    itemsPerPage?: string | number;\n    currentPage?: string | number;\n    totalItems?: string | number;\n}\n\nexport interface PipeState {\n    collection: ArrayLike<any>;\n    size: number;\n    start: number;\n    end: number;\n    slice: ArrayLike<any>;\n}\n\n@Pipe({\n    name: 'paginate',\n    pure: false\n})\nexport class GIPIPaginatePipe {\n\n    // Armazenar os valores da última vez que o pipe foi invocado\n    private _state: { [id: string]: PipeState } = {};\n\n    constructor(private _service: GIPIPaginationService) { }\n\n    public transform<T, U extends Collection<T>>(collection: U, args: PaginatePipeArgs): U {\n\n        // Quando um observável é passado pelo AsyncPipe, ele produzirá\n        // `null` até que a assinatura seja resolvida. Neste caso, queremos\n        // usar os dados em cache do objeto `_state` para evitar que o NgFor\n        // pisque vazio até que os valores reais cheguem.\n        if (!(collection instanceof Array)) {\n            let _id = args.id || this._service.defaultId();\n            if (this._state[_id]) {\n                return this._state[_id].slice as U;\n            } else {\n                return collection;\n            }\n        }\n\n        let serverSideMode: boolean = args.totalItems && args.totalItems !== collection.length;\n        let instance: PaginationInstance = this.createInstance(collection, args);\n        let id: string = instance.id;\n        let start: number;\n        let end: number;\n        let perPage: number = instance.itemsPerPage;\n\n        let emitChange: boolean = this._service.register(instance);\n\n        if (!serverSideMode && collection instanceof Array) {\n            perPage = +perPage || LARGE_NUMBER;\n            start = (instance.currentPage - 1) * perPage;\n            end = start + perPage;\n\n            let isIdentical = this.stateIsIdentical(id, collection, start, end);\n            if (isIdentical) {\n                return this._state[id].slice as U;\n            } else {\n                let slice = collection.slice(start, end);\n                this.saveState(id, collection, slice, start, end);\n                this._service.change.emit(id);\n                return slice as U;\n            }\n        } else {\n            if (emitChange) {\n                this._service.change.emit(id);\n            }\n\n            // salve o estado para coleta do lado do servidor para evitar nulo\n            // pisca à medida que novos dados são carregados.\n            this.saveState(id, collection, collection, start, end);\n\n            return collection;\n        }\n    }\n\n    /**\n     * Crie um objeto PaginationInstance, usando padrões para quaisquer propriedades opcionais não fornecidas.\n     */\n    private createInstance(collection: readonly any[], config: PaginatePipeArgs): PaginationInstance {\n        this.checkConfig(config);\n\n        return {\n            id: config.id != null ? config.id : this._service.defaultId(),\n            itemsPerPage: +config.itemsPerPage || 0,\n            currentPage: +config.currentPage || 1,\n            totalItems: +config.totalItems || collection.length\n        };\n    }\n\n    /**\n     * Assegure-se de que o argumento passado para o filtro contenha as propriedades necessárias.\n     */\n    private checkConfig(config: PaginatePipeArgs): void {\n        const required = ['itemsPerPage', 'currentPage'];\n\n        const missing = required.filter(prop => !(prop in config));\n        if (0 < missing.length) {\n            throw new Error(`PaginatePipe: Argumento está faltando as seguintes propriedades necessárias: ${missing.join(', ')}`);\n        }\n    }\n\n    /**\n     * Para evitar o retorno de um novo array toda vez que o pipe é executado, armazenamos o estado do sliced\n     * array para um determinado id. Isso significa que na próxima vez que o canal for executado nesta coleção e id, apenas\n     * precisa verificar se a coleta, os pontos inicial e final são todos idênticos e, em caso afirmativo, retornar o\n     * último array fatiado.\n     */\n    private saveState(id: string, collection: ArrayLike<any>, slice: ArrayLike<any>, start: number, end: number) {\n        this._state[id] = {\n            collection,\n            size: collection.length,\n            slice,\n            start,\n            end\n        };\n    }\n\n    /**\n     * Para um determinado id, retorna true se os valores de coleção, tamanho, início e fim forem idênticos.\n     */\n    private stateIsIdentical(id: string, collection: ArrayLike<any>, start: number, end: number): boolean {\n        let state = this._state[id];\n        if (!state) {\n            return false;\n        }\n        let isMetaDataIdentical = state.size === collection.length &&\n            state.start === start &&\n            state.end === end;\n\n        if (!isMetaDataIdentical) {\n            return false;\n        }\n\n        return (state.slice as Array<any>).every((element, index) => element === collection[start + index]);\n    }\n}\n"]}

package/esm5/shared/gipi-components/table/components/table-pagination/shared/pagination-controls.directive.js

@@ -0,0 +1,228 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectorRef, Directive, EventEmitter, Input, Output } from '@angular/core';
+import { GIPIPaginationService } from './pagination.service';
+/**
+ * Esta diretiva é o que alimenta todos os componentes de controle de paginação, incluindo o padrão.
+ * Ele expõe uma API conectada ao GIPIPaginationService para manter o PaginatePipe sincronizado
+ * com os controles de paginação.
+ */
+var GIPIPaginationControlsDirective = /** @class */ (function () {
+    function GIPIPaginationControlsDirective(_service, _changeDetectorRef) {
+        var _this = this;
+        this._service = _service;
+        this._changeDetectorRef = _changeDetectorRef;
+        this.pages = [];
+        this.maxSize = 5;
+        this.pageChange = new EventEmitter();
+        this.pageBoundsCorrection = new EventEmitter();
+        this.changeSub = this._service.change.subscribe(function (id) {
+            if (_this.id === id) {
+                _this.updatePageLinks();
+                _this._changeDetectorRef.markForCheck();
+                _this._changeDetectorRef.detectChanges();
+            }
+        });
+    }
+    GIPIPaginationControlsDirective.prototype.ngOnInit = function () {
+        if (this.id === undefined) {
+            this.id = this._service.defaultId();
+        }
+        this.updatePageLinks();
+    };
+    GIPIPaginationControlsDirective.prototype.ngOnChanges = function (changes) {
+        this.updatePageLinks();
+    };
+    GIPIPaginationControlsDirective.prototype.ngOnDestroy = function () {
+        this.changeSub.unsubscribe();
+    };
+    /**
+     * Ir para a página anterior
+     */
+    GIPIPaginationControlsDirective.prototype.previous = function () {
+        this.checkValidId();
+        this.setCurrent(this.getCurrent() - 1);
+    };
+    /**
+     * Vá para a página seguinte
+     */
+    GIPIPaginationControlsDirective.prototype.next = function () {
+        this.checkValidId();
+        this.setCurrent(this.getCurrent() + 1);
+    };
+    /**
+     * Retorna true se a página atual for a primeira página
+     */
+    GIPIPaginationControlsDirective.prototype.isFirstPage = function () {
+        return this.getCurrent() === 1;
+    };
+    /**
+     * Retorna true se a página atual for a última página
+     */
+    GIPIPaginationControlsDirective.prototype.isLastPage = function () {
+        return this.getLastPage() === this.getCurrent();
+    };
+    /**
+     * Defina o número da página atual
+     */
+    GIPIPaginationControlsDirective.prototype.setCurrent = function (page) {
+        this.pageChange.emit(page);
+    };
+    /**
+     * Obtenha o número da página atual
+     */
+    GIPIPaginationControlsDirective.prototype.getCurrent = function () {
+        return this._service.getCurrentPage(this.id);
+    };
+    /**
+     * Retorna o número da última página
+     */
+    GIPIPaginationControlsDirective.prototype.getLastPage = function () {
+        var inst = this._service.getInstance(this.id);
+        if (inst.totalItems < 1) {
+            // quando há 0 ou menos itens (um caso de erro), não há "páginas" como tal,
+            // mas faz sentido considerar uma única página vazia como a última página.
+            return 1;
+        }
+        return Math.ceil(inst.totalItems / inst.itemsPerPage);
+    };
+    /**
+     * Retorna a quantidade total de páginas
+     */
+    GIPIPaginationControlsDirective.prototype.getTotalItems = function () {
+        return this._service.getInstance(this.id).totalItems;
+    };
+    /**
+     * Verifica se o id da PaginationInstance é válido
+     */
+    GIPIPaginationControlsDirective.prototype.checkValidId = function () {
+        if (this._service.getInstance(this.id).id == null) {
+            console.warn("PaginationControlsDirective: O id especificado \"" + this.id + "\" n\u00E3o corresponde a nenhuma PaginationInstance registrada");
+        }
+    };
+    /**
+     * Atualiza os links da página e verifica se a página atual é válida. Deve ser executado sempre que o
+     * PaginationService.change stream emite um valor correspondente ao ID atual ou quando qualquer um das
+     * mudanças nos valores de entrada.
+     */
+    GIPIPaginationControlsDirective.prototype.updatePageLinks = function () {
+        var _this = this;
+        var inst = this._service.getInstance(this.id);
+        var correctedCurrentPage = this.outOfBoundCorrection(inst);
+        if (correctedCurrentPage !== inst.currentPage) {
+            setTimeout(function () {
+                _this.pageBoundsCorrection.emit(correctedCurrentPage);
+                _this.pages = _this.createPageArray(inst.currentPage, inst.itemsPerPage, inst.totalItems, _this.maxSize);
+            });
+        }
+        else {
+            this.pages = this.createPageArray(inst.currentPage, inst.itemsPerPage, inst.totalItems, this.maxSize);
+        }
+    };
+    /**
+     * Verifica se a propriedade instance.currentPage está dentro dos limites do intervalo de páginas atual.
+     * Caso contrário, retorne um valor correto para currentPage ou o valor atual se OK.
+     */
+    GIPIPaginationControlsDirective.prototype.outOfBoundCorrection = function (instance) {
+        var totalPages = Math.ceil(instance.totalItems / instance.itemsPerPage);
+        if (totalPages < instance.currentPage && 0 < totalPages) {
+            return totalPages;
+        }
+        else if (instance.currentPage < 1) {
+            return 1;
+        }
+        return instance.currentPage;
+    };
+    /**
+     * Retorna uma matriz de objetos Page para usar nos controles de paginação.
+     */
+    GIPIPaginationControlsDirective.prototype.createPageArray = function (currentPage, itemsPerPage, totalItems, paginationRange) {
+        // paginationRange pode ser uma string se for passada de atributo, então converta para number.
+        paginationRange = +paginationRange;
+        var pages = [];
+        // Retorne 1 como número de página padrão
+        // Faz sentido mostrar 1 em vez de vazio quando não há itens
+        var totalPages = Math.max(Math.ceil(totalItems / itemsPerPage), 1);
+        var halfWay = Math.ceil(paginationRange / 2);
+        var isStart = currentPage <= halfWay;
+        var isEnd = totalPages - halfWay < currentPage;
+        var isMiddle = !isStart && !isEnd;
+        var ellipsesNeeded = paginationRange < totalPages;
+        var i = 1;
+        while (i <= totalPages && i <= paginationRange) {
+            var label = void 0;
+            var pageNumber = this.calculatePageNumber(i, currentPage, paginationRange, totalPages);
+            var openingEllipsesNeeded = (i === 2 && (isMiddle || isEnd));
+            var closingEllipsesNeeded = (i === paginationRange - 1 && (isMiddle || isStart));
+            if (ellipsesNeeded && (openingEllipsesNeeded || closingEllipsesNeeded)) {
+                label = '...';
+            }
+            else {
+                label = String(pageNumber);
+            }
+            pages.push({
+                label: label,
+                value: pageNumber
+            });
+            i++;
+        }
+        return pages;
+    };
+    /**
+     * Dada a posição na sequência de links de paginação [i],
+     * descubra qual número de página corresponde a essa posição.
+     */
+    GIPIPaginationControlsDirective.prototype.calculatePageNumber = function (i, currentPage, paginationRange, totalPages) {
+        var halfWay = Math.ceil(paginationRange / 2);
+        if (i === paginationRange) {
+            return totalPages;
+        }
+        else if (i === 1) {
+            return i;
+        }
+        else if (paginationRange < totalPages) {
+            if (totalPages - halfWay < currentPage) {
+                return totalPages - paginationRange + i;
+            }
+            else if (halfWay < currentPage) {
+                return currentPage - halfWay + i;
+            }
+            else {
+                return i;
+            }
+        }
+        else {
+            return i;
+        }
+    };
+    GIPIPaginationControlsDirective.ctorParameters = function () { return [
+        { type: GIPIPaginationService },
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIPaginationControlsDirective.prototype, "id", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPIPaginationControlsDirective.prototype, "maxSize", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIPaginationControlsDirective.prototype, "pageChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIPaginationControlsDirective.prototype, "pageBoundsCorrection", void 0);
+    GIPIPaginationControlsDirective = __decorate([
+        Directive({
+            selector: 'pagination-template,[pagination-template]',
+            exportAs: 'paginationApi'
+        }),
+        __metadata("design:paramtypes", [GIPIPaginationService,
+            ChangeDetectorRef])
+    ], GIPIPaginationControlsDirective);
+    return GIPIPaginationControlsDirective;
+}());
+export { GIPIPaginationControlsDirective };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination-controls.directive.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/table/components/table-pagination/shared/pagination-controls.directive.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAI1F,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAO7D;;;;GAIG;AAKH;IAaI,yCACY,QAA+B,EAC/B,kBAAqC;QAFjD,iBAWC;QAVW,aAAQ,GAAR,QAAQ,CAAuB;QAC/B,uBAAkB,GAAlB,kBAAkB,CAAmB;QAXjD,UAAK,GAAW,EAAE,CAAC;QAIV,YAAO,GAAW,CAAC,CAAC;QAEnB,eAAU,GAAyB,IAAI,YAAY,EAAU,CAAC;QAC9D,yBAAoB,GAAyB,IAAI,YAAY,EAAU,CAAC;QAM9E,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,UAAA,EAAE;YAC9C,IAAI,KAAI,CAAC,EAAE,KAAK,EAAE,EAAE;gBAChB,KAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,KAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;gBACvC,KAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,CAAC;aAC3C;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,kDAAQ,GAAR;QACI,IAAI,IAAI,CAAC,EAAE,KAAK,SAAS,EAAE;YACvB,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;SACvC;QAED,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;IAED,qDAAW,GAAX,UAAY,OAAY;QACpB,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;IAED,qDAAW,GAAX;QACI,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,kDAAQ,GAAR;QACI,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,8CAAI,GAAJ;QACI,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,qDAAW,GAAX;QACI,OAAO,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,oDAAU,GAAV;QACI,OAAO,IAAI,CAAC,WAAW,EAAE,KAAK,IAAI,CAAC,UAAU,EAAE,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,oDAAU,GAAV,UAAW,IAAY;QACnB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,oDAAU,GAAV;QACI,OAAO,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjD,CAAC;IAED;;OAEG;IACH,qDAAW,GAAX;QACI,IAAI,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC9C,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,EAAE;YACrB,2EAA2E;YAC3E,0EAA0E;YAC1E,OAAO,CAAC,CAAC;SACZ;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;IAC1D,CAAC;IAED;;OAEG;IACH,uDAAa,GAAb;QACI,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC;IACzD,CAAC;IAED;;OAEG;IACK,sDAAY,GAApB;QACI,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,IAAI,EAAE;YAC/C,OAAO,CAAC,IAAI,CAAC,sDAAmD,IAAI,CAAC,EAAE,oEAA2D,CAAC,CAAC;SACvI;IACL,CAAC;IAED;;;;OAIG;IACK,yDAAe,GAAvB;QAAA,iBAYC;QAXG,IAAI,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC9C,IAAM,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAE7D,IAAI,oBAAoB,KAAK,IAAI,CAAC,WAAW,EAAE;YAC3C,UAAU,CAAC;gBACP,KAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBACrD,KAAI,CAAC,KAAK,GAAG,KAAI,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,UAAU,EAAE,KAAI,CAAC,OAAO,CAAC,CAAC;YAC1G,CAAC,CAAC,CAAC;SACN;aAAM;YACH,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;SACzG;IACL,CAAC;IAED;;;OAGG;IACK,8DAAoB,GAA5B,UAA6B,QAA4B;QACrD,IAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;QAC1E,IAAI,UAAU,GAAG,QAAQ,CAAC,WAAW,IAAI,CAAC,GAAG,UAAU,EAAE;YACrD,OAAO,UAAU,CAAC;SACrB;aAAM,IAAI,QAAQ,CAAC,WAAW,GAAG,CAAC,EAAE;YACjC,OAAO,CAAC,CAAC;SACZ;QAED,OAAO,QAAQ,CAAC,WAAW,CAAC;IAChC,CAAC;IAED;;OAEG;IACK,yDAAe,GAAvB,UAAwB,WAAmB,EAAE,YAAoB,EAAE,UAAkB,EAAE,eAAuB;QAC1G,8FAA8F;QAC9F,eAAe,GAAG,CAAC,eAAe,CAAC;QACnC,IAAI,KAAK,GAAG,EAAE,CAAC;QAEf,yCAAyC;QACzC,4DAA4D;QAC5D,IAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC;QACrE,IAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC,CAAC;QAE/C,IAAM,OAAO,GAAG,WAAW,IAAI,OAAO,CAAC;QACvC,IAAM,KAAK,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,CAAC;QACjD,IAAM,QAAQ,GAAG,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC;QAEpC,IAAI,cAAc,GAAG,eAAe,GAAG,UAAU,CAAC;QAClD,IAAI,CAAC,GAAG,CAAC,CAAC;QAEV,OAAO,CAAC,IAAI,UAAU,IAAI,CAAC,IAAI,eAAe,EAAE;YAC5C,IAAI,KAAK,SAAQ,CAAC;YAClB,IAAI,UAAU,GAAG,IAAI,CAAC,mBAAmB,CAAC,CAAC,EAAE,WAAW,EAAE,eAAe,EAAE,UAAU,CAAC,CAAC;YACvF,IAAI,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC;YAC7D,IAAI,qBAAqB,GAAG,CAAC,CAAC,KAAK,eAAe,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,CAAC,CAAC;YACjF,IAAI,cAAc,IAAI,CAAC,qBAAqB,IAAI,qBAAqB,CAAC,EAAE;gBACpE,KAAK,GAAG,KAAK,CAAC;aACjB;iBAAM;gBACH,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;aAC9B;YACD,KAAK,CAAC,IAAI,CAAC;gBACP,KAAK,EAAE,KAAK;gBACZ,KAAK,EAAE,UAAU;aACpB,CAAC,CAAC;YACH,CAAC,EAAE,CAAC;SACP;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;OAGG;IACK,6DAAmB,GAA3B,UAA4B,CAAS,EAAE,WAAmB,EAAE,eAAuB,EAAE,UAAkB;QACnG,IAAI,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC,CAAC;QAC7C,IAAI,CAAC,KAAK,eAAe,EAAE;YACvB,OAAO,UAAU,CAAC;SACrB;aAAM,IAAI,CAAC,KAAK,CAAC,EAAE;YAChB,OAAO,CAAC,CAAC;SACZ;aAAM,IAAI,eAAe,GAAG,UAAU,EAAE;YACrC,IAAI,UAAU,GAAG,OAAO,GAAG,WAAW,EAAE;gBACpC,OAAO,UAAU,GAAG,eAAe,GAAG,CAAC,CAAC;aAC3C;iBAAM,IAAI,OAAO,GAAG,WAAW,EAAE;gBAC9B,OAAO,WAAW,GAAG,OAAO,GAAG,CAAC,CAAC;aACpC;iBAAM;gBACH,OAAO,CAAC,CAAC;aACZ;SACJ;aAAM;YACH,OAAO,CAAC,CAAC;SACZ;IACL,CAAC;;gBAnMqB,qBAAqB;gBACX,iBAAiB;;IATxC;QAAR,KAAK,EAAE;;+DAAY;IAEX;QAAR,KAAK,EAAE;;oEAAqB;IAEnB;QAAT,MAAM,EAAE;kCAAa,YAAY;uEAAsC;IAC9D;QAAT,MAAM,EAAE;kCAAuB,YAAY;iFAAsC;IAXzE,+BAA+B;QAJ3C,SAAS,CAAC;YACP,QAAQ,EAAE,2CAA2C;YACrD,QAAQ,EAAE,eAAe;SAC5B,CAAC;yCAewB,qBAAqB;YACX,iBAAiB;OAfxC,+BAA+B,CAmN3C;IAAD,sCAAC;CAAA,AAnND,IAmNC;SAnNY,+BAA+B","sourcesContent":["import { ChangeDetectorRef, Directive, EventEmitter, Input, Output } from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport { PaginationInstance } from './pagination-instance';\nimport { GIPIPaginationService } from './pagination.service';\n\nexport interface Page {\n    label: string;\n    value: any;\n}\n\n/**\n * Esta diretiva é o que alimenta todos os componentes de controle de paginação, incluindo o padrão.\n * Ele expõe uma API conectada ao GIPIPaginationService para manter o PaginatePipe sincronizado\n * com os controles de paginação.\n */\n@Directive({\n    selector: 'pagination-template,[pagination-template]',\n    exportAs: 'paginationApi'\n})\nexport class GIPIPaginationControlsDirective {\n\n    private changeSub: Subscription;\n\n    pages: Page[] = [];\n\n    @Input() id: string;\n\n    @Input() maxSize: number = 5;\n\n    @Output() pageChange: EventEmitter<number> = new EventEmitter<number>();\n    @Output() pageBoundsCorrection: EventEmitter<number> = new EventEmitter<number>();\n\n    constructor(\n        private _service: GIPIPaginationService,\n        private _changeDetectorRef: ChangeDetectorRef,\n    ) {\n        this.changeSub = this._service.change.subscribe(id => {\n            if (this.id === id) {\n                this.updatePageLinks();\n                this._changeDetectorRef.markForCheck();\n                this._changeDetectorRef.detectChanges();\n            }\n        });\n    }\n\n    ngOnInit() {\n        if (this.id === undefined) {\n            this.id = this._service.defaultId();\n        }\n\n        this.updatePageLinks();\n    }\n\n    ngOnChanges(changes: any) {\n        this.updatePageLinks();\n    }\n\n    ngOnDestroy() {\n        this.changeSub.unsubscribe();\n    }\n\n    /**\n     * Ir para a página anterior\n     */\n    previous() {\n        this.checkValidId();\n        this.setCurrent(this.getCurrent() - 1);\n    }\n\n    /**\n     * Vá para a página seguinte\n     */\n    next() {\n        this.checkValidId();\n        this.setCurrent(this.getCurrent() + 1);\n    }\n\n    /**\n     * Retorna true se a página atual for a primeira página\n     */\n    isFirstPage(): boolean {\n        return this.getCurrent() === 1;\n    }\n\n    /**\n     * Retorna true se a página atual for a última página\n     */\n    isLastPage(): boolean {\n        return this.getLastPage() === this.getCurrent();\n    }\n\n    /**\n     * Defina o número da página atual\n     */\n    setCurrent(page: number) {\n        this.pageChange.emit(page);\n    }\n\n    /**\n     * Obtenha o número da página atual\n     */\n    getCurrent(): number {\n        return this._service.getCurrentPage(this.id);\n    }\n\n    /**\n     * Retorna o número da última página\n     */\n    getLastPage(): number {\n        let inst = this._service.getInstance(this.id);\n        if (inst.totalItems < 1) {\n            // quando há 0 ou menos itens (um caso de erro), não há \"páginas\" como tal,\n            // mas faz sentido considerar uma única página vazia como a última página.\n            return 1;\n        }\n        return Math.ceil(inst.totalItems / inst.itemsPerPage);\n    }\n\n    /**\n     * Retorna a quantidade total de páginas\n     */\n    getTotalItems(): number {\n        return this._service.getInstance(this.id).totalItems;\n    }\n\n    /**\n     * Verifica se o id da PaginationInstance é válido\n     */\n    private checkValidId() {\n        if (this._service.getInstance(this.id).id == null) {\n            console.warn(`PaginationControlsDirective: O id especificado \"${this.id}\" não corresponde a nenhuma PaginationInstance registrada`);\n        }\n    }\n\n    /**\n     * Atualiza os links da página e verifica se a página atual é válida. Deve ser executado sempre que o\n     * PaginationService.change stream emite um valor correspondente ao ID atual ou quando qualquer um das\n     * mudanças nos valores de entrada.\n     */\n    private updatePageLinks() {\n        let inst = this._service.getInstance(this.id);\n        const correctedCurrentPage = this.outOfBoundCorrection(inst);\n\n        if (correctedCurrentPage !== inst.currentPage) {\n            setTimeout(() => {\n                this.pageBoundsCorrection.emit(correctedCurrentPage);\n                this.pages = this.createPageArray(inst.currentPage, inst.itemsPerPage, inst.totalItems, this.maxSize);\n            });\n        } else {\n            this.pages = this.createPageArray(inst.currentPage, inst.itemsPerPage, inst.totalItems, this.maxSize);\n        }\n    }\n\n    /**\n     * Verifica se a propriedade instance.currentPage está dentro dos limites do intervalo de páginas atual.\n     * Caso contrário, retorne um valor correto para currentPage ou o valor atual se OK.\n     */\n    private outOfBoundCorrection(instance: PaginationInstance): number {\n        const totalPages = Math.ceil(instance.totalItems / instance.itemsPerPage);\n        if (totalPages < instance.currentPage && 0 < totalPages) {\n            return totalPages;\n        } else if (instance.currentPage < 1) {\n            return 1;\n        }\n\n        return instance.currentPage;\n    }\n\n    /**\n     * Retorna uma matriz de objetos Page para usar nos controles de paginação.\n     */\n    private createPageArray(currentPage: number, itemsPerPage: number, totalItems: number, paginationRange: number): Page[] {\n        // paginationRange pode ser uma string se for passada de atributo, então converta para number.\n        paginationRange = +paginationRange;\n        let pages = [];\n\n        // Retorne 1 como número de página padrão\n        // Faz sentido mostrar 1 em vez de vazio quando não há itens\n        const totalPages = Math.max(Math.ceil(totalItems / itemsPerPage), 1);\n        const halfWay = Math.ceil(paginationRange / 2);\n\n        const isStart = currentPage <= halfWay;\n        const isEnd = totalPages - halfWay < currentPage;\n        const isMiddle = !isStart && !isEnd;\n\n        let ellipsesNeeded = paginationRange < totalPages;\n        let i = 1;\n\n        while (i <= totalPages && i <= paginationRange) {\n            let label: string;\n            let pageNumber = this.calculatePageNumber(i, currentPage, paginationRange, totalPages);\n            let openingEllipsesNeeded = (i === 2 && (isMiddle || isEnd));\n            let closingEllipsesNeeded = (i === paginationRange - 1 && (isMiddle || isStart));\n            if (ellipsesNeeded && (openingEllipsesNeeded || closingEllipsesNeeded)) {\n                label = '...';\n            } else {\n                label = String(pageNumber);\n            }\n            pages.push({\n                label: label,\n                value: pageNumber\n            });\n            i++;\n        }\n        return pages;\n    }\n\n    /**\n     * Dada a posição na sequência de links de paginação [i],\n     * descubra qual número de página corresponde a essa posição.\n     */\n    private calculatePageNumber(i: number, currentPage: number, paginationRange: number, totalPages: number) {\n        let halfWay = Math.ceil(paginationRange / 2);\n        if (i === paginationRange) {\n            return totalPages;\n        } else if (i === 1) {\n            return i;\n        } else if (paginationRange < totalPages) {\n            if (totalPages - halfWay < currentPage) {\n                return totalPages - paginationRange + i;\n            } else if (halfWay < currentPage) {\n                return currentPage - halfWay + i;\n            } else {\n                return i;\n            }\n        } else {\n            return i;\n        }\n    }\n\n}\n"]}

package/esm5/shared/gipi-components/table/components/table-pagination/shared/pagination-instance.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnaW5hdGlvbi1pbnN0YW5jZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbInNoYXJlZC9naXBpLWNvbXBvbmVudHMvdGFibGUvY29tcG9uZW50cy90YWJsZS1wYWdpbmF0aW9uL3NoYXJlZC9wYWdpbmF0aW9uLWluc3RhbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFBhZ2luYXRpb25JbnN0YW5jZSB7XG5cbiAgICAvKipcbiAgICAgKiBVbSBJRCBvcGNpb25hbCBwYXJhIGEgaW5zdMOibmNpYSBkZSBwYWdpbmHDp8Ojby4gU8OzIMOpIMO6dGlsIHNlIHZvY8OqIHF1aXNlclxuICAgICAqIHRlciBtYWlzIGRlIHVtYSBpbnN0w6JuY2lhIHBvciB2ZXogZW0gdW0gZGV0ZXJtaW5hZG8gY29tcG9uZW50ZS5cbiAgICAgKi9cbiAgICBpZD86IHN0cmluZztcblxuICAgIC8qKlxuICAgICAqIE8gbsO6bWVybyBkZSBpdGVucyBwb3IgcMOhZ2luYSBwYWdpbmFkYS5cbiAgICAgKi9cbiAgICBpdGVtc1BlclBhZ2U6IG51bWJlcjtcblxuICAgIC8qKlxuICAgICAqIEEgcMOhZ2luYSBhdHVhbCAoYXRpdmEpLlxuICAgICAqL1xuICAgIGN1cnJlbnRQYWdlOiBudW1iZXI7XG5cbiAgICAvKipcbiAgICAgKiBPIG7Dum1lcm8gdG90YWwgZGUgaXRlbnMgbmEgY29sZcOnw6NvLiDDmnRpbCBhcGVuYXMgcXVhbmRvXG4gICAgICogZmF6ZW5kbyBwYWdpbmHDp8OjbyBkbyBsYWRvIGRvIHNlcnZpZG9yLCBvbmRlIG8gdGFtYW5obyBkYSBjb2xlw6fDo28gw6kgbGltaXRhZG9cbiAgICAgKiBwYXJhIHVtYSDDum5pY2EgcMOhZ2luYSByZXRvcm5hZGEgcGVsYSBBUEkgZG8gc2Vydmlkb3IuXG4gICAgICpcbiAgICAgKiBQYXJhIHBhZ2luYcOnw6NvIG5hIG1lbcOzcmlhLCBlc3NhIHByb3ByaWVkYWRlIG7Do28gZGV2ZSBzZXIgZGVmaW5pZGEsIHBvaXNcbiAgICAgKiBzZXLDoSBkZWZpbmlkbyBhdXRvbWF0aWNhbWVudGUgY29tIG8gdmFsb3IgZGUgY29sbGVjdGlvbi5sZW5ndGguXG4gICAgICovXG4gICAgdG90YWxJdGVtcz86IG51bWJlcjtcblxufVxuIl19