@gipisistemas/ng-core 1.1.0 → 1.1.1

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

@@ -0,0 +1,225 @@
+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.
+ */
+let GIPIPaginationControlsDirective = class GIPIPaginationControlsDirective {
+    constructor(_service, _changeDetectorRef) {
+        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(id => {
+            if (this.id === id) {
+                this.updatePageLinks();
+                this._changeDetectorRef.markForCheck();
+                this._changeDetectorRef.detectChanges();
+            }
+        });
+    }
+    ngOnInit() {
+        if (this.id === undefined) {
+            this.id = this._service.defaultId();
+        }
+        this.updatePageLinks();
+    }
+    ngOnChanges(changes) {
+        this.updatePageLinks();
+    }
+    ngOnDestroy() {
+        this.changeSub.unsubscribe();
+    }
+    /**
+     * Ir para a página anterior
+     */
+    previous() {
+        this.checkValidId();
+        this.setCurrent(this.getCurrent() - 1);
+    }
+    /**
+     * Vá para a página seguinte
+     */
+    next() {
+        this.checkValidId();
+        this.setCurrent(this.getCurrent() + 1);
+    }
+    /**
+     * Retorna true se a página atual for a primeira página
+     */
+    isFirstPage() {
+        return this.getCurrent() === 1;
+    }
+    /**
+     * Retorna true se a página atual for a última página
+     */
+    isLastPage() {
+        return this.getLastPage() === this.getCurrent();
+    }
+    /**
+     * Defina o número da página atual
+     */
+    setCurrent(page) {
+        this.pageChange.emit(page);
+    }
+    /**
+     * Obtenha o número da página atual
+     */
+    getCurrent() {
+        return this._service.getCurrentPage(this.id);
+    }
+    /**
+     * Retorna o número da última página
+     */
+    getLastPage() {
+        let 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
+     */
+    getTotalItems() {
+        return this._service.getInstance(this.id).totalItems;
+    }
+    /**
+     * Verifica se o id da PaginationInstance é válido
+     */
+    checkValidId() {
+        if (this._service.getInstance(this.id).id == null) {
+            console.warn(`PaginationControlsDirective: O id especificado "${this.id}" não 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.
+     */
+    updatePageLinks() {
+        let inst = this._service.getInstance(this.id);
+        const correctedCurrentPage = this.outOfBoundCorrection(inst);
+        if (correctedCurrentPage !== inst.currentPage) {
+            setTimeout(() => {
+                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.
+     */
+    outOfBoundCorrection(instance) {
+        const 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.
+     */
+    createPageArray(currentPage, itemsPerPage, totalItems, paginationRange) {
+        // paginationRange pode ser uma string se for passada de atributo, então converta para number.
+        paginationRange = +paginationRange;
+        let pages = [];
+        // Retorne 1 como número de página padrão
+        // Faz sentido mostrar 1 em vez de vazio quando não há itens
+        const totalPages = Math.max(Math.ceil(totalItems / itemsPerPage), 1);
+        const halfWay = Math.ceil(paginationRange / 2);
+        const isStart = currentPage <= halfWay;
+        const isEnd = totalPages - halfWay < currentPage;
+        const isMiddle = !isStart && !isEnd;
+        let ellipsesNeeded = paginationRange < totalPages;
+        let i = 1;
+        while (i <= totalPages && i <= paginationRange) {
+            let label;
+            let pageNumber = this.calculatePageNumber(i, currentPage, paginationRange, totalPages);
+            let openingEllipsesNeeded = (i === 2 && (isMiddle || isEnd));
+            let 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.
+     */
+    calculatePageNumber(i, currentPage, paginationRange, totalPages) {
+        let 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 = () => [
+    { 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);
+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":"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","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/esm2015/shared/gipi-components/table/components/table-pagination/shared/pagination-instance.js

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

package/esm2015/shared/gipi-components/table/components/table-pagination/shared/pagination.service.js

@@ -0,0 +1,105 @@
+import { EventEmitter } from '@angular/core';
+export class GIPIPaginationService {
+    constructor() {
+        this._instances = {};
+        this._DEFAULT_ID = 'DEFAULT_PAGINATION_ID';
+        this.change = new EventEmitter();
+    }
+    defaultId() {
+        return this._DEFAULT_ID;
+    }
+    /**
+     * Registre uma PaginationInstance com este serviço. Retorna um
+     * valor booleano significando se a instância é nova ou atualizada.
+     * (true = new or updated, false = unchanged).
+     */
+    register(instance) {
+        if (instance.id == null) {
+            instance.id = this._DEFAULT_ID;
+        }
+        if (!this._instances[instance.id]) {
+            this._instances[instance.id] = instance;
+            return true;
+        }
+        else {
+            return this.updateInstance(instance);
+        }
+    }
+    /**
+     * Verifique cada propriedade da instância e atualize as que foram alteradas. Retornar
+     * true se alguma alteração foi feita, senão retorna false.
+     */
+    updateInstance(instance) {
+        let changed = false;
+        for (let prop in this._instances[instance.id]) {
+            if (instance[prop] !== this._instances[instance.id][prop]) {
+                this._instances[instance.id][prop] = instance[prop];
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    /**
+     * Retorna o número da página atual.
+     */
+    getCurrentPage(id) {
+        if (this._instances[id]) {
+            return this._instances[id].currentPage;
+        }
+        return 1;
+    }
+    /**
+     * Define o número da página atual.
+     */
+    setCurrentPage(id, page) {
+        if (this._instances[id]) {
+            let instance = this._instances[id];
+            let maxPage = Math.ceil(instance.totalItems / instance.itemsPerPage);
+            if (page <= maxPage && 1 <= page) {
+                this._instances[id].currentPage = page;
+                this.change.emit(id);
+            }
+        }
+    }
+    /**
+     * Define o valor de instance.totalItems
+     */
+    setTotalItems(id, totalItems) {
+        if (this._instances[id] && 0 <= totalItems) {
+            this._instances[id].totalItems = totalItems;
+            this.change.emit(id);
+        }
+    }
+    /**
+     * Define o valor de instance.itemsPerPage
+     */
+    setItemsPerPage(id, itemsPerPage) {
+        if (this._instances[id]) {
+            this._instances[id].itemsPerPage = itemsPerPage;
+            this.change.emit(id);
+        }
+    }
+    /**
+     * Retorna um clone do objeto de instância de paginação correspondente ao id. Se não tiver
+     * id especificado, retorna a instância correspondente ao id padrão.
+     */
+    getInstance(id = this._DEFAULT_ID) {
+        if (this._instances[id]) {
+            return this.clone(this._instances[id]);
+        }
+        return {};
+    }
+    /**
+     * Execute um clone raso de um objeto.
+     */
+    clone(obj) {
+        var target = {};
+        for (var i in obj) {
+            if (obj.hasOwnProperty(i)) {
+                target[i] = obj[i];
+            }
+        }
+        return target;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.service.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/table/components/table-pagination/shared/pagination.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from '@angular/core';\nimport { PaginationInstance } from './pagination-instance';\n\nexport class GIPIPaginationService {\n\n    private _instances: { [id: string]: PaginationInstance } = {};\n    private _DEFAULT_ID = 'DEFAULT_PAGINATION_ID';\n\n    public change: EventEmitter<string> = new EventEmitter<string>();\n\n    constructor() { }\n\n    public defaultId(): string {\n        return this._DEFAULT_ID;\n    }\n\n    /**\n     * Registre uma PaginationInstance com este serviço. Retorna um\n     * valor booleano significando se a instância é nova ou atualizada.\n     * (true = new or updated, false = unchanged).\n     */\n    public register(instance: PaginationInstance): boolean {\n        if (instance.id == null) {\n            instance.id = this._DEFAULT_ID;\n        }\n\n        if (!this._instances[instance.id]) {\n            this._instances[instance.id] = instance;\n            return true;\n        } else {\n            return this.updateInstance(instance);\n        }\n    }\n\n    /**\n     * Verifique cada propriedade da instância e atualize as que foram alteradas. Retornar\n     * true se alguma alteração foi feita, senão retorna false.\n     */\n    private updateInstance(instance: PaginationInstance): boolean {\n        let changed = false;\n        for (let prop in this._instances[instance.id]) {\n            if (instance[prop] !== this._instances[instance.id][prop]) {\n                this._instances[instance.id][prop] = instance[prop];\n                changed = true;\n            }\n        }\n        return changed;\n    }\n\n    /**\n     * Retorna o número da página atual.\n     */\n    public getCurrentPage(id: string): number {\n        if (this._instances[id]) {\n            return this._instances[id].currentPage;\n        }\n        return 1;\n    }\n\n    /**\n     * Define o número da página atual.\n     */\n    public setCurrentPage(id: string, page: number) {\n        if (this._instances[id]) {\n            let instance = this._instances[id];\n            let maxPage = Math.ceil(instance.totalItems / instance.itemsPerPage);\n\n            if (page <= maxPage && 1 <= page) {\n                this._instances[id].currentPage = page;\n                this.change.emit(id);\n            }\n        }\n    }\n\n    /**\n     * Define o valor de instance.totalItems\n     */\n    public setTotalItems(id: string, totalItems: number) {\n        if (this._instances[id] && 0 <= totalItems) {\n            this._instances[id].totalItems = totalItems;\n            this.change.emit(id);\n        }\n    }\n\n    /**\n     * Define o valor de instance.itemsPerPage\n     */\n    public setItemsPerPage(id: string, itemsPerPage: number) {\n        if (this._instances[id]) {\n            this._instances[id].itemsPerPage = itemsPerPage;\n            this.change.emit(id);\n        }\n    }\n\n    /**\n     * Retorna um clone do objeto de instância de paginação correspondente ao id. Se não tiver\n     * id especificado, retorna a instância correspondente ao id padrão.\n     */\n    public getInstance(id: string = this._DEFAULT_ID): PaginationInstance {\n        if (this._instances[id]) {\n            return this.clone(this._instances[id]);\n        }\n        return {} as PaginationInstance;\n    }\n\n    /**\n     * Execute um clone raso de um objeto.\n     */\n    private clone(obj: any): any {\n        var target = {};\n        for (var i in obj) {\n            if (obj.hasOwnProperty(i)) {\n                target[i] = obj[i];\n            }\n        }\n        return target;\n    }\n\n}\n"]}

package/esm2015/shared/gipi-components/table/components/table-pagination/table-pagination.component.js

@@ -0,0 +1,102 @@
+var GIPITablePaginationComponent_1;
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+let GIPITablePaginationComponent = GIPITablePaginationComponent_1 = class GIPITablePaginationComponent {
+    constructor() {
+        this.maxSize = 5;
+        this._directionLinks = true;
+        this._autoHide = false;
+        this._responsive = false;
+        this.previousTooltip = 'Voltar';
+        this.nextTooltip = 'Avançar';
+        this.pageChange = new EventEmitter();
+        this.pageBoundsCorrection = new EventEmitter();
+    }
+    set directionLinks(value) {
+        this._directionLinks = coerceToBoolean(value);
+    }
+    get directionLinks() {
+        return this._directionLinks;
+    }
+    set autoHide(value) {
+        this._autoHide = coerceToBoolean(value);
+    }
+    get autoHide() {
+        return this._autoHide;
+    }
+    set responsive(value) {
+        this._responsive = coerceToBoolean(value);
+    }
+    get responsive() {
+        return this._responsive;
+    }
+    ngOnInit() { }
+    trackByIndex(index) {
+        return index;
+    }
+};
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPITablePaginationComponent.prototype, "id", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], GIPITablePaginationComponent.prototype, "maxSize", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], GIPITablePaginationComponent.prototype, "directionLinks", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], GIPITablePaginationComponent.prototype, "autoHide", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], GIPITablePaginationComponent.prototype, "responsive", null);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPITablePaginationComponent.prototype, "previousTooltip", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPITablePaginationComponent.prototype, "nextTooltip", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], GIPITablePaginationComponent.prototype, "pageChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], GIPITablePaginationComponent.prototype, "pageBoundsCorrection", void 0);
+GIPITablePaginationComponent = GIPITablePaginationComponent_1 = __decorate([
+    Component({
+        selector: `gipi-table-pagination`,
+        exportAs: 'gipiTablePagination',
+        template: "<pagination-template #pageAPI=\"paginationApi\"\n                     [id]=\"id\"\n                     [maxSize]=\"maxSize\"\n                     (pageChange)=\"pageChange.emit($event)\"\n                     (pageBoundsCorrection)=\"pageBoundsCorrection.emit($event)\">\n\n    <nav role=\"navigation\">\n\n        <ul class=\"pagination-content\"\n            [class.responsive]=\"responsive\"\n            *ngIf=\"!(autoHide && pageAPI.pages.length <= 1)\">\n\n            <li class=\"pagination-previous\"\n                [class.disabled]=\"pageAPI.isFirstPage()\"\n                [matTooltip]=\"!pageAPI.isFirstPage() ? previousTooltip : ''\"\n                *ngIf=\"directionLinks\"\n                (keyup.enter)=\"pageAPI.previous()\"\n                (click)=\"1 < pageAPI.getCurrent() ? pageAPI.previous() : null\">\n                <a tabindex=\"0\">\n                    <mat-icon> chevron_left </mat-icon>\n                </a>\n            </li>\n\n            <li class=\"small-screen\">\n                {{ pageAPI.getCurrent() }} / {{ pageAPI.getLastPage() }}\n            </li>\n\n            <li [class.current]=\"pageAPI.getCurrent() === page.value\"\n                [class.ellipsis]=\"page.label === '...'\"\n                *ngFor=\"let page of pageAPI.pages; trackBy: trackByIndex\"\n                (keyup.enter)=\"pageAPI.setCurrent(page.value)\"\n                (click)=\"pageAPI.setCurrent(page.value)\">\n                <a tabindex=\"0\"\n                   *ngIf=\"pageAPI.getCurrent() !== page.value\">\n                    {{ (page.label === '...') ? page.label : (page.label | number:'') }}\n                </a>\n                <ng-container *ngIf=\"pageAPI.getCurrent() === page.value\">\n                    <span aria-live=\"polite\">\n                        {{ (page.label === '...') ? page.label : (page.label | number:'') }}\n                    </span>\n                </ng-container>\n            </li>\n\n            <li class=\"pagination-next\"\n                [class.disabled]=\"pageAPI.isLastPage()\"\n                [matTooltip]=\"!pageAPI.isLastPage() ? nextTooltip : ''\"\n                *ngIf=\"directionLinks\"\n                (keyup.enter)=\"pageAPI.next()\"\n                (click)=\"!pageAPI.isLastPage() ? pageAPI.next() : null\">\n                <a tabindex=\"0\">\n                    <mat-icon> chevron_right </mat-icon>\n                </a>\n            </li>\n\n        </ul>\n\n    </nav>\n\n</pagination-template>",
+        providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => GIPITablePaginationComponent_1),
+                multi: true
+            }
+        ],
+        host: {
+            'class': 'gipi-table-pagination',
+        },
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        styles: [".pagination-content{display:flex;align-items:center;gap:4px}.pagination-content>li{display:flex;align-items:center;justify-content:center;list-style:none;width:2.8rem;height:2.8rem;padding:.8rem;border-radius:4px;border:1px solid transparent;font-size:1.2rem;line-height:1.8rem;font-weight:500;color:#595959;transition:.2s;cursor:pointer}.pagination-content>li.pagination-next,.pagination-content>li.pagination-previous{border-color:#595959}.pagination-content>li.pagination-next>a,.pagination-content>li.pagination-next>a>mat-icon,.pagination-content>li.pagination-next>span,.pagination-content>li.pagination-next>span>mat-icon,.pagination-content>li.pagination-previous>a,.pagination-content>li.pagination-previous>a>mat-icon,.pagination-content>li.pagination-previous>span,.pagination-content>li.pagination-previous>span>mat-icon{width:1.8rem;height:1.8rem;font-size:1.8rem}.pagination-content>li:not(.current):not(.disabled):not(.pagination-previous):not(.pagination-next):hover{background-color:#f5f5f6;border-color:#e0e1e2}.pagination-content>li.pagination-next:hover,.pagination-content>li.pagination-previous:hover{background-color:#f5f5f6}.pagination-content>li.current:hover{background-color:#cc2d38}.pagination-content>li.current{background-color:#e0313e;border-color:transparent;color:#fff;cursor:default}.pagination-content>li.pagination-next.disabled,.pagination-content>li.pagination-previous.disabled{color:#d1d2d4!important;border-color:#d1d2d4!important;cursor:not-allowed!important}.pagination-content>li.disabled{color:#d1d2d4!important;cursor:not-allowed!important}.pagination-content .small-screen{display:none}@media screen and (max-width:601px){.pagination-content.responsive .small-screen{display:inline-block}.pagination-content.responsive li:not(.small-screen):not(.pagination-previous):not(.pagination-next){display:none}}"]
+    }),
+    __metadata("design:paramtypes", [])
+], GIPITablePaginationComponent);
+export { GIPITablePaginationComponent };
+function coerceToBoolean(input) {
+    return !!input && input !== 'false';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtcGFnaW5hdGlvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AZ2lwaXNpc3RlbWFzL25nLWNvcmUvIiwic291cmNlcyI6WyJzaGFyZWQvZ2lwaS1jb21wb25lbnRzL3RhYmxlL2NvbXBvbmVudHMvdGFibGUtcGFnaW5hdGlvbi90YWJsZS1wYWdpbmF0aW9uLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBVSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3BILE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBbUJuRCxJQUFhLDRCQUE0QixvQ0FBekMsTUFBYSw0QkFBNEI7SUFxQ3JDO1FBakNTLFlBQU8sR0FBVyxDQUFDLENBQUM7UUFFckIsb0JBQWUsR0FBWSxJQUFJLENBQUM7UUFRaEMsY0FBUyxHQUFZLEtBQUssQ0FBQztRQVEzQixnQkFBVyxHQUFZLEtBQUssQ0FBQztRQVE1QixvQkFBZSxHQUFXLFFBQVEsQ0FBQztRQUVuQyxnQkFBVyxHQUFXLFNBQVMsQ0FBQztRQUUvQixlQUFVLEdBQXlCLElBQUksWUFBWSxFQUFVLENBQUM7UUFDOUQseUJBQW9CLEdBQXlCLElBQUksWUFBWSxFQUFVLENBQUM7SUFFbEUsQ0FBQztJQTlCUixJQUFJLGNBQWMsQ0FBQyxLQUFjO1FBQ3RDLElBQUksQ0FBQyxlQUFlLEdBQUcsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFDRCxJQUFJLGNBQWM7UUFDZCxPQUFPLElBQUksQ0FBQyxlQUFlLENBQUM7SUFDaEMsQ0FBQztJQUdRLElBQUksUUFBUSxDQUFDLEtBQWM7UUFDaEMsSUFBSSxDQUFDLFNBQVMsR0FBRyxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUNELElBQUksUUFBUTtRQUNSLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQztJQUMxQixDQUFDO0lBR1EsSUFBSSxVQUFVLENBQUMsS0FBYztRQUNsQyxJQUFJLENBQUMsV0FBVyxHQUFHLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM5QyxDQUFDO0lBQ0QsSUFBSSxVQUFVO1FBQ1YsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQzVCLENBQUM7SUFXRCxRQUFRLEtBQVcsQ0FBQztJQUVwQixZQUFZLENBQUMsS0FBYTtRQUN0QixPQUFPLEtBQUssQ0FBQztJQUNqQixDQUFDO0NBRUosQ0FBQTtBQTNDWTtJQUFSLEtBQUssRUFBRTs7d0RBQVk7QUFFWDtJQUFSLEtBQUssRUFBRTs7NkRBQXFCO0FBR3BCO0lBQVIsS0FBSyxFQUFFOzs7a0VBRVA7QUFNUTtJQUFSLEtBQUssRUFBRTs7OzREQUVQO0FBTVE7SUFBUixLQUFLLEVBQUU7Ozs4REFFUDtBQUtRO0lBQVIsS0FBSyxFQUFFOztxRUFBb0M7QUFFbkM7SUFBUixLQUFLLEVBQUU7O2lFQUFpQztBQUUvQjtJQUFULE1BQU0sRUFBRTs4QkFBYSxZQUFZO2dFQUFzQztBQUM5RDtJQUFULE1BQU0sRUFBRTs4QkFBdUIsWUFBWTswRUFBc0M7QUFuQ3pFLDRCQUE0QjtJQWpCeEMsU0FBUyxDQUFDO1FBQ1AsUUFBUSxFQUFFLHVCQUF1QjtRQUNqQyxRQUFRLEVBQUUscUJBQXFCO1FBQy9CLHc4RUFBZ0Q7UUFFaEQsU0FBUyxFQUFFO1lBQ1A7Z0JBQ0ksT0FBTyxFQUFFLGlCQUFpQjtnQkFDMUIsV0FBVyxFQUFFLFVBQVUsQ0FBQyxHQUF3QyxFQUFFLENBQUMsOEJBQTRCLENBQUM7Z0JBQ2hHLEtBQUssRUFBRSxJQUFJO2FBQ2Q7U0FDSjtRQUNELElBQUksRUFBRTtZQUNGLE9BQU8sRUFBRSx1QkFBdUI7U0FDbkM7UUFDRCxlQUFlLEVBQUUsdUJBQXVCLENBQUMsTUFBTTs7S0FDbEQsQ0FBQzs7R0FDVyw0QkFBNEIsQ0E2Q3hDO1NBN0NZLDRCQUE0QjtBQStDekMsU0FBUyxlQUFlLENBQUMsS0FBdUI7SUFDNUMsT0FBTyxDQUFDLENBQUMsS0FBSyxJQUFJLEtBQUssS0FBSyxPQUFPLENBQUM7QUFDeEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIEV2ZW50RW1pdHRlciwgSW5wdXQsIE9uSW5pdCwgT3V0cHV0LCBmb3J3YXJkUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBOR19WQUxVRV9BQ0NFU1NPUiB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6IGBnaXBpLXRhYmxlLXBhZ2luYXRpb25gLFxuICAgIGV4cG9ydEFzOiAnZ2lwaVRhYmxlUGFnaW5hdGlvbicsXG4gICAgdGVtcGxhdGVVcmw6ICcuL3RhYmxlLXBhZ2luYXRpb24uY29tcG9uZW50Lmh0bWwnLFxuICAgIHN0eWxlVXJsczogWycuL3RhYmxlLXBhZ2luYXRpb24uY29tcG9uZW50LnNjc3MnXSxcbiAgICBwcm92aWRlcnM6IFtcbiAgICAgICAge1xuICAgICAgICAgICAgcHJvdmlkZTogTkdfVkFMVUVfQUNDRVNTT1IsXG4gICAgICAgICAgICB1c2VFeGlzdGluZzogZm9yd2FyZFJlZigoKTogdHlwZW9mIEdJUElUYWJsZVBhZ2luYXRpb25Db21wb25lbnQgPT4gR0lQSVRhYmxlUGFnaW5hdGlvbkNvbXBvbmVudCksXG4gICAgICAgICAgICBtdWx0aTogdHJ1ZVxuICAgICAgICB9XG4gICAgXSxcbiAgICBob3N0OiB7XG4gICAgICAgICdjbGFzcyc6ICdnaXBpLXRhYmxlLXBhZ2luYXRpb24nLFxuICAgIH0sXG4gICAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcbn0pXG5leHBvcnQgY2xhc3MgR0lQSVRhYmxlUGFnaW5hdGlvbkNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG5cbiAgICBASW5wdXQoKSBpZDogc3RyaW5nO1xuXG4gICAgQElucHV0KCkgbWF4U2l6ZTogbnVtYmVyID0gNTtcblxuICAgIHByaXZhdGUgX2RpcmVjdGlvbkxpbmtzOiBib29sZWFuID0gdHJ1ZTtcbiAgICBASW5wdXQoKSBzZXQgZGlyZWN0aW9uTGlua3ModmFsdWU6IGJvb2xlYW4pIHtcbiAgICAgICAgdGhpcy5fZGlyZWN0aW9uTGlua3MgPSBjb2VyY2VUb0Jvb2xlYW4odmFsdWUpO1xuICAgIH1cbiAgICBnZXQgZGlyZWN0aW9uTGlua3MoKTogYm9vbGVhbiB7XG4gICAgICAgIHJldHVybiB0aGlzLl9kaXJlY3Rpb25MaW5rcztcbiAgICB9XG5cbiAgICBwcml2YXRlIF9hdXRvSGlkZTogYm9vbGVhbiA9IGZhbHNlO1xuICAgIEBJbnB1dCgpIHNldCBhdXRvSGlkZSh2YWx1ZTogYm9vbGVhbikge1xuICAgICAgICB0aGlzLl9hdXRvSGlkZSA9IGNvZXJjZVRvQm9vbGVhbih2YWx1ZSk7XG4gICAgfVxuICAgIGdldCBhdXRvSGlkZSgpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX2F1dG9IaWRlO1xuICAgIH1cblxuICAgIHByaXZhdGUgX3Jlc3BvbnNpdmU6IGJvb2xlYW4gPSBmYWxzZTtcbiAgICBASW5wdXQoKSBzZXQgcmVzcG9uc2l2ZSh2YWx1ZTogYm9vbGVhbikge1xuICAgICAgICB0aGlzLl9yZXNwb25zaXZlID0gY29lcmNlVG9Cb29sZWFuKHZhbHVlKTtcbiAgICB9XG4gICAgZ2V0IHJlc3BvbnNpdmUoKTogYm9vbGVhbiB7XG4gICAgICAgIHJldHVybiB0aGlzLl9yZXNwb25zaXZlO1xuICAgIH1cblxuICAgIEBJbnB1dCgpIHByZXZpb3VzVG9vbHRpcDogc3RyaW5nID0gJ1ZvbHRhcic7XG5cbiAgICBASW5wdXQoKSBuZXh0VG9vbHRpcDogc3RyaW5nID0gJ0F2YW7Dp2FyJztcblxuICAgIEBPdXRwdXQoKSBwYWdlQ2hhbmdlOiBFdmVudEVtaXR0ZXI8bnVtYmVyPiA9IG5ldyBFdmVudEVtaXR0ZXI8bnVtYmVyPigpO1xuICAgIEBPdXRwdXQoKSBwYWdlQm91bmRzQ29ycmVjdGlvbjogRXZlbnRFbWl0dGVyPG51bWJlcj4gPSBuZXcgRXZlbnRFbWl0dGVyPG51bWJlcj4oKTtcblxuICAgIGNvbnN0cnVjdG9yKCkgeyB9XG5cbiAgICBuZ09uSW5pdCgpOiB2b2lkIHsgfVxuXG4gICAgdHJhY2tCeUluZGV4KGluZGV4OiBudW1iZXIpIHtcbiAgICAgICAgcmV0dXJuIGluZGV4O1xuICAgIH1cblxufVxuXG5mdW5jdGlvbiBjb2VyY2VUb0Jvb2xlYW4oaW5wdXQ6IHN0cmluZyB8IGJvb2xlYW4pOiBib29sZWFuIHtcbiAgICByZXR1cm4gISFpbnB1dCAmJiBpbnB1dCAhPT0gJ2ZhbHNlJztcbn1cbiJdfQ==

package/esm2015/shared/gipi-components/table/components/table-progress-bar/table-progress-bar.component.js

@@ -0,0 +1,30 @@
+var GIPITableProgressBarComponent_1;
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, Component, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+let GIPITableProgressBarComponent = GIPITableProgressBarComponent_1 = class GIPITableProgressBarComponent {
+    constructor() { }
+    ngOnInit() { }
+};
+GIPITableProgressBarComponent = GIPITableProgressBarComponent_1 = __decorate([
+    Component({
+        selector: `gipi-table-progress-bar`,
+        exportAs: 'gipiTableProgressBar',
+        template: "<div class=\"progress-linear\"\n     role=\"progressbar\">\n    <div class=\"indeterminate-progress-bar\">\n        <div class=\"bar\"> </div>\n    </div>\n</div>",
+        providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => GIPITableProgressBarComponent_1),
+                multi: true
+            }
+        ],
+        host: {
+            'class': 'gipi-table-progress-bar',
+        },
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        styles: [".progress-linear{display:block;position:-webkit-sticky;position:sticky;width:100%;height:5px;padding:0;margin:0;top:0}.progress-linear .indeterminate-progress-bar{background-color:#f5bfc3;height:5px;position:relative;overflow:hidden}.progress-linear .indeterminate-progress-bar .bar{background-color:#e0313e;border-radius:9999px;position:absolute;bottom:0;top:0;width:100%;-webkit-animation-duration:1s;animation-duration:1s;-webkit-animation-iteration-count:infinite;animation-iteration-count:infinite;-webkit-animation-name:indeterminate-progress-bar;animation-name:indeterminate-progress-bar}@-webkit-keyframes indeterminate-progress-bar{from{left:-50%}to{left:100%}}@keyframes indeterminate-progress-bar{from{left:-50%}to{left:100%}}"]
+    }),
+    __metadata("design:paramtypes", [])
+], GIPITableProgressBarComponent);
+export { GIPITableProgressBarComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/shared/gipi-components/table/models/pipe-transform.model.js

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

package/esm2015/shared/gipi-components/table/models/sort.model.js

@@ -0,0 +1,19 @@
+export class SortModel {
+    constructor(property, direction) {
+        this.property = property;
+        this.direction = direction;
+    }
+    get property() {
+        return this._property;
+    }
+    set property(value) {
+        this._property = value;
+    }
+    get direction() {
+        return this._direction;
+    }
+    set direction(value) {
+        this._direction = value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbInNoYXJlZC9naXBpLWNvbXBvbmVudHMvdGFibGUvbW9kZWxzL3NvcnQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLFNBQVM7SUFNbEIsWUFDSSxRQUFnQixFQUNoQixTQUF3QjtRQUV4QixJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztRQUN6QixJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztJQUMvQixDQUFDO0lBRUQsSUFBVyxRQUFRO1FBQ2YsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQzFCLENBQUM7SUFDRCxJQUFXLFFBQVEsQ0FBQyxLQUFhO1FBQzdCLElBQUksQ0FBQyxTQUFTLEdBQUcsS0FBSyxDQUFDO0lBQzNCLENBQUM7SUFFRCxJQUFXLFNBQVM7UUFDaEIsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDO0lBQzNCLENBQUM7SUFDRCxJQUFXLFNBQVMsQ0FBQyxLQUFvQjtRQUNyQyxJQUFJLENBQUMsVUFBVSxHQUFHLEtBQUssQ0FBQztJQUM1QixDQUFDO0NBRUoiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTb3J0RGlyZWN0aW9uIH0gZnJvbSAnLi4vdHlwZXMvc29ydC1kaXJlY3Rpb24udHlwZSc7XG5cbmV4cG9ydCBjbGFzcyBTb3J0TW9kZWwge1xuXG4gICAgcHJpdmF0ZSBfcHJvcGVydHk6IHN0cmluZztcblxuICAgIHByaXZhdGUgX2RpcmVjdGlvbjogU29ydERpcmVjdGlvbjtcblxuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwcm9wZXJ0eTogc3RyaW5nLFxuICAgICAgICBkaXJlY3Rpb246IFNvcnREaXJlY3Rpb25cbiAgICApIHtcbiAgICAgICAgdGhpcy5wcm9wZXJ0eSA9IHByb3BlcnR5O1xuICAgICAgICB0aGlzLmRpcmVjdGlvbiA9IGRpcmVjdGlvbjtcbiAgICB9XG5cbiAgICBwdWJsaWMgZ2V0IHByb3BlcnR5KCk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiB0aGlzLl9wcm9wZXJ0eTtcbiAgICB9XG4gICAgcHVibGljIHNldCBwcm9wZXJ0eSh2YWx1ZTogc3RyaW5nKSB7XG4gICAgICAgIHRoaXMuX3Byb3BlcnR5ID0gdmFsdWU7XG4gICAgfVxuXG4gICAgcHVibGljIGdldCBkaXJlY3Rpb24oKTogU29ydERpcmVjdGlvbiB7XG4gICAgICAgIHJldHVybiB0aGlzLl9kaXJlY3Rpb247XG4gICAgfVxuICAgIHB1YmxpYyBzZXQgZGlyZWN0aW9uKHZhbHVlOiBTb3J0RGlyZWN0aW9uKSB7XG4gICAgICAgIHRoaXMuX2RpcmVjdGlvbiA9IHZhbHVlO1xuICAgIH1cblxufVxuIl19

package/esm2015/shared/gipi-components/table/models/sorted-column.model.js

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