@colijnit/corecomponents_v12 12.0.44 → 12.0.47

package/esm2015/colijnit-corecomponents_v12.js

@@ -10,6 +10,8 @@ export { BaseGridComponent as ɵq } from './lib/components/grid/base/base-grid.c
 export { BaseInlineEditGridComponent as ɵo } from './lib/components/grid/base/base-inline-edit-grid.component';
 export { BaseSelectionGridComponent as ɵn } from './lib/components/grid/base/base-selection-grid.component';
 export { BaseToolbarGridComponent as ɵp } from './lib/components/grid/base/base-toolbar-grid.component';
+export { PaginatePipe as ɵbg } from './lib/components/pagination/paginate.pipe';
+export { PaginationService as ɵbf } from './lib/components/pagination/pagination.service';
 export { PopupShowerService as ɵx } from './lib/components/popup/service/popup-shower.service';
 export { BaseSimpleGridComponent as ɵy } from './lib/components/simple-grid/base-simple-grid.component';
 export { SimpleGridCellComponent as ɵba } from './lib/components/simple-grid/simple-grid-cell.component';
@@ -32,4 +34,4 @@ export { AppendPipe as ɵs } from './lib/pipes/append.pipe';
 export { AppendPipeModule as ɵr } from './lib/pipes/append.pipe.module';
 export { PrependPipe as ɵbc } from './lib/pipes/prepend.pipe';
 export { PrependPipeModule as ɵbb } from './lib/pipes/prepend.pipe.module';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/input-date-range-picker/input-date-range-picker.component.js

@@ -10,6 +10,7 @@ export class InputDateRangePickerComponent extends BaseInputComponent {
         this.dateRangeChange = new EventEmitter();
         this.close = new EventEmitter();
         this.select = new EventEmitter();
+        this.cleared = new EventEmitter();
     }
     showClass() {
         return true;
@@ -33,6 +34,7 @@ InputDateRangePickerComponent.decorators = [
       (ngModelChange)="rangeChange()"
       (close)="close.next($event)"
       (select)="select.next($event)"
+      (cleared)="cleared.next($event)"
       [(startDate)]="startDate"
       [(endDate)]="endDate"
     ></ejs-daterangepicker>
@@ -52,6 +54,7 @@ InputDateRangePickerComponent.propDecorators = {
     dateRangeChange: [{ type: Output }],
     close: [{ type: Output }],
     select: [{ type: Output }],
+    cleared: [{ type: Output }],
     showClass: [{ type: HostBinding, args: ["class.co-input-date-range-picker",] }]
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/pagination/paginate.pipe.js

@@ -0,0 +1,106 @@
+import { Pipe } from "@angular/core";
+import { PaginationService } from "./pagination.service";
+const LARGE_NUMBER = 999999999;
+export class PaginatePipe {
+    constructor(paginateService) {
+        this.paginateService = paginateService;
+        // store the values from the last time the pipe
+        this.state = {};
+    }
+    transform(collection, args) {
+        // When an observable is passed through the AsyncPipe, it will output
+        // `null` until the subscription resolves. In this case, we want to
+        // use the cached data from the `state` object to prevent the NgFor
+        // from flashing empty until the real values arrive.
+        if (!(collection instanceof Array)) {
+            let _id = args.id || this.paginateService.DEFAULT_ID;
+            if (this.state[_id]) {
+                return this.state[_id].slice;
+            }
+            else {
+                return collection;
+            }
+        }
+        let serverSideMode = args.totalItems !== undefined;
+        let instance = this._createInstance(collection, args);
+        let id = instance.id;
+        let start;
+        let end;
+        let perPage = instance.itemsPerPage;
+        this.paginateService.register(instance);
+        if (!serverSideMode && collection instanceof Array) {
+            perPage = perPage || LARGE_NUMBER;
+            start = (instance.currentPage - 1) * perPage;
+            end = start + perPage;
+            let isIdentical = this._stateIsIdentical(id, collection, start, end);
+            if (isIdentical) {
+                return this.state[id].slice;
+            }
+            else {
+                let slice = collection.slice(start, end);
+                this._saveState(id, collection, slice, start, end);
+                this.paginateService.change.next(id);
+                return slice;
+            }
+        }
+        // save the state for server-side collection to avoid null
+        // flash as new data loads.
+        this._saveState(id, collection, collection, start, end);
+        return collection;
+    }
+    // Create an IPaginationInstance object, using defaults for any optional properties not supplied.
+    _createInstance(collection, args) {
+        let config = args;
+        this._checkConfig(config);
+        return {
+            id: config.id || this.paginateService.DEFAULT_ID,
+            itemsPerPage: config.itemsPerPage || 0,
+            currentPage: config.currentPage || 1,
+            totalItems: config.totalItems || collection.length
+        };
+    }
+    // Ensure the argument passed to the filter contains the required properties.
+    _checkConfig(config) {
+        const required = ["itemsPerPage", "currentPage"];
+        const missing = required.filter((prop) => !config.hasOwnProperty(prop));
+        if (0 < missing.length) {
+            throw new Error(`PaginatePipe: Argument is missing the following required properties: ${missing.join(", ")}`);
+        }
+    }
+    /**
+     * To avoid returning a brand new array each time the pipe is run, we store the state of the sliced
+     * array for a given id. This means that the next time the pipe is run on this collection & id, we just
+     * need to check that the collection, start and end points are all identical, and if so, return the
+     * last sliced array.
+     */
+    _saveState(id, collection, slice, start, end) {
+        this.state[id] = {
+            collection,
+            size: collection.length,
+            slice,
+            start,
+            end
+        };
+    }
+    // For a given id, returns true if the collection, size, start and end values are identical.
+    _stateIsIdentical(id, collection, start, end) {
+        let state = this.state[id];
+        if (!state) {
+            return false;
+        }
+        return state.collection === collection &&
+            state.size === collection.length &&
+            state.start === start &&
+            state.end === end;
+    }
+}
+PaginatePipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'paginate',
+                pure: false
+            },] }
+];
+PaginatePipe.ctorParameters = () => [
+    { type: PaginationService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paginate.pipe.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/pagination/paginate.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import {Pipe, PipeTransform} from \"@angular/core\";\r\n\r\nimport {PaginationService} from \"./pagination.service\";\r\nimport {IPaginationInstance} from \"./pagination-instance\";\r\n\r\nconst LARGE_NUMBER: number = 999999999;\r\n\r\ninterface IPipeState {\r\n    collection: any[];\r\n    size: number;\r\n    start: number;\r\n    end: number;\r\n    slice: any[];\r\n}\r\n\r\n@Pipe({\r\n    name: 'paginate',\r\n    pure: false\r\n})\r\nexport class PaginatePipe implements PipeTransform {\r\n\r\n    // store the values from the last time the pipe\r\n    private state: { [id: string]: IPipeState } = {};\r\n\r\n    constructor(private paginateService: PaginationService) {\r\n    }\r\n\r\n    public transform(collection: any[], args: any): any {\r\n        // When an observable is passed through the AsyncPipe, it will output\r\n        // `null` until the subscription resolves. In this case, we want to\r\n        // use the cached data from the `state` object to prevent the NgFor\r\n        // from flashing empty until the real values arrive.\r\n        if (!(collection instanceof Array)) {\r\n            let _id: any = args.id || this.paginateService.DEFAULT_ID;\r\n            if (this.state[_id]) {\r\n                return this.state[_id].slice;\r\n            } else {\r\n                return collection;\r\n            }\r\n        }\r\n\r\n        let serverSideMode: boolean = args.totalItems !== undefined;\r\n        let instance: IPaginationInstance = this._createInstance(collection, args);\r\n        let id: string = instance.id;\r\n        let start: number;\r\n        let end: number;\r\n        let perPage: number = instance.itemsPerPage;\r\n\r\n        this.paginateService.register(instance);\r\n\r\n        if (!serverSideMode && collection instanceof Array) {\r\n            perPage = perPage || LARGE_NUMBER;\r\n            start = (instance.currentPage - 1) * perPage;\r\n            end = start + perPage;\r\n\r\n            let isIdentical: boolean = this._stateIsIdentical(id, collection, start, end);\r\n            if (isIdentical) {\r\n                return this.state[id].slice;\r\n            } else {\r\n                let slice: any[] = collection.slice(start, end);\r\n                this._saveState(id, collection, slice, start, end);\r\n                this.paginateService.change.next(id);\r\n                return slice;\r\n            }\r\n        }\r\n\r\n        // save the state for server-side collection to avoid null\r\n        // flash as new data loads.\r\n        this._saveState(id, collection, collection, start, end);\r\n        return collection;\r\n    }\r\n\r\n    // Create an IPaginationInstance object, using defaults for any optional properties not supplied.\r\n    private _createInstance(collection: any[], args: any): IPaginationInstance {\r\n        let config: any = args;\r\n        this._checkConfig(config);\r\n\r\n        return {\r\n            id: config.id || this.paginateService.DEFAULT_ID,\r\n            itemsPerPage: config.itemsPerPage || 0,\r\n            currentPage: config.currentPage || 1,\r\n            totalItems: config.totalItems || collection.length\r\n        };\r\n    }\r\n\r\n    // Ensure the argument passed to the filter contains the required properties.\r\n    private _checkConfig(config: any): void {\r\n        const required: String[] = [\"itemsPerPage\", \"currentPage\"];\r\n        const missing: String[] = required.filter((prop: any) => !config.hasOwnProperty(prop));\r\n        if (0 < missing.length) {\r\n            throw new Error(`PaginatePipe: Argument is missing the following required properties: ${missing.join(\", \")}`);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * To avoid returning a brand new array each time the pipe is run, we store the state of the sliced\r\n     * array for a given id. This means that the next time the pipe is run on this collection & id, we just\r\n     * need to check that the collection, start and end points are all identical, and if so, return the\r\n     * last sliced array.\r\n     */\r\n    private _saveState(id: string, collection: any[], slice: any[], start: number, end: number): void {\r\n        this.state[id] = {\r\n            collection,\r\n            size: collection.length,\r\n            slice,\r\n            start,\r\n            end\r\n        };\r\n    }\r\n\r\n    // For a given id, returns true if the collection, size, start and end values are identical.\r\n    private _stateIsIdentical(id: string, collection: any[], start: number, end: number): boolean {\r\n        let state: any = this.state[id];\r\n        if (!state) {\r\n            return false;\r\n        }\r\n        return state.collection === collection &&\r\n            state.size === collection.length &&\r\n            state.start === start &&\r\n            state.end === end;\r\n    }\r\n}"]}

package/esm2015/lib/components/pagination/pagination-instance.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnaW5hdGlvbi1pbnN0YW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9wYWdpbmF0aW9uL3BhZ2luYXRpb24taW5zdGFuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8vIFJlcHJlc2VudHMgYSBwYWdpbmF0aW9uIGluc3RhbmNlOiB0aGUgY29uZmlndXJhdGlvbiBvYmplY3QgZm9yIGEgc2luZ2xlIHBhZ2luYXRpb24gY29tcG9uZW50LlxyXG5leHBvcnQgaW50ZXJmYWNlIElQYWdpbmF0aW9uSW5zdGFuY2Uge1xyXG4gICAgLy8gQW4gb3B0aW9uYWwgSUQgZm9yIHRoZSBwYWdpbmF0aW9uIGluc3RhbmNlLiBPbmx5IHVzZWZ1bCBpZiB5b3Ugd2lzaCB0byBoYXZlIG1vcmUgdGhhbiBvbmNlIGluc3RhbmNlIGF0IGEgdGltZSBpbiBhIGdpdmVuIGNvbXBvbmVudC5cclxuICAgIGlkPzogc3RyaW5nO1xyXG4gICAgLy8gVGhlIG51bWJlciBvZiBpdGVtcyBwZXIgcGFnaW5hdGVkIHBhZ2UuXHJcbiAgICBpdGVtc1BlclBhZ2U6IG51bWJlcjtcclxuICAgIC8vIFRoZSBjdXJyZW50IChhY3RpdmUpIHBhZ2UuXHJcbiAgICBjdXJyZW50UGFnZTogbnVtYmVyO1xyXG4gICAgLyoqXHJcbiAgICAgKiBUaGUgdG90YWwgbnVtYmVyIG9mIGl0ZW1zIGluIHRoZSBjb2xsZWN0aW9uLiBPbmx5IHVzZWZ1bCB3aGVuXHJcbiAgICAgKiBkb2luZyBzZXJ2ZXItc2lkZSBwYWdpbmcsIHdoZXJlIHRoZSBjb2xsZWN0aW9uIHNpemUgaXMgbGltaXRlZFxyXG4gICAgICogdG8gYSBzaW5nbGUgcGFnZSByZXR1cm5lZCBieSB0aGUgc2VydmVyIEFQSS5cclxuICAgICAqXHJcbiAgICAgKiBGb3IgaW4tbWVtb3J5IHBhZ2luZywgdGhpcyBwcm9wZXJ0eSBzaG91bGQgbm90IGJlIHNldCwgYXMgaXRcclxuICAgICAqIHdpbGwgYmUgYXV0b21hdGljYWxseSBzZXQgdG8gdGhlIHZhbHVlIG9mICBjb2xsZWN0aW9uLmxlbmd0aC5cclxuICAgICAqL1xyXG4gICAgdG90YWxJdGVtcz86IG51bWJlcjtcclxufSJdfQ==

package/esm2015/lib/components/pagination/pagination.component.js

@@ -0,0 +1,194 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { PaginationService } from './pagination.service';
+export class PaginationComponent {
+    constructor(_paginationService) {
+        this._paginationService = _paginationService;
+        this.maxSize = 7;
+        this.directionLinks = true;
+        this.previousLabel = 'Vorige pagina';
+        this.nextLabel = 'Volgende pagina';
+        this.autoHide = false;
+        // Emits the new page number.
+        this.pageChange = new EventEmitter();
+        this.showClass = true;
+        this.pages = [];
+        this.changeSub = this._paginationService.change.subscribe((id) => {
+            if (this.id === id) {
+                this._updatePageLinks();
+            }
+        });
+    }
+    ngOnInit() {
+        if (!this.id) {
+            this.id = this._paginationService.DEFAULT_ID;
+        }
+        this._updatePageLinks();
+    }
+    ngOnChanges() {
+        this._updatePageLinks();
+    }
+    ngOnDestroy() {
+        this.changeSub.unsubscribe();
+    }
+    goToFirstPage() {
+        if (!this.isOnFirstPage()) {
+            this.setCurrentPage(1);
+        }
+    }
+    goToPreviousPage() {
+        if (!this.isOnFirstPage()) {
+            this.setCurrentPage(this.getCurrentPage() - 1);
+        }
+    }
+    goToNextPage() {
+        if (!this.isOnLastPage()) {
+            this.setCurrentPage(this.getCurrentPage() + 1);
+        }
+    }
+    setCurrentPage(page) {
+        this.pageChange.emit(page);
+    }
+    isOnFirstPage() {
+        return this.getCurrentPage() === 1;
+    }
+    isOnLastPage() {
+        return this.getLastPage() === this.getCurrentPage();
+    }
+    shouldBeHidden() {
+        if (!this.autoHide) {
+            return false;
+        }
+        else {
+            let instance = this._paginationService.getInstance();
+            return (instance.totalItems <= instance.itemsPerPage);
+        }
+    }
+    /**
+     * Updates the page links and checks that the current page is valid. Should run whenever the
+     * PaginationService.change stream emits a value matching the current ID, or when any of the
+     * input values changes.
+     */
+    _updatePageLinks() {
+        let paginationInstance = this._paginationService.getInstance(this.id);
+        this.pages = this.createPageArray(paginationInstance.currentPage, paginationInstance.itemsPerPage, paginationInstance.totalItems, this.maxSize);
+        const correctedCurrentPage = this.outOfBoundCorrection(paginationInstance);
+        if (correctedCurrentPage !== paginationInstance.currentPage) {
+            this.setCurrentPage(correctedCurrentPage);
+        }
+    }
+    getCurrentPage() {
+        return this._paginationService.getCurrentPage(this.id);
+    }
+    getLastPage() {
+        let instance = this._paginationService.getInstance(this.id);
+        return Math.ceil(instance.totalItems / instance.itemsPerPage);
+    }
+    /**
+     * Checks that the instance.currentPage property is within bounds for the current page range.
+     * If not, return a correct value for currentPage, or the current value if 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;
+    }
+    // Returns an array of IPage objects to use in the pagination controls.
+    createPageArray(currentPage, itemsPerPage, totalItems, paginationRange) {
+        // paginationRange could be a string if passed from attribute, so cast to number.
+        paginationRange = +paginationRange;
+        let pages = [];
+        const totalPages = Math.ceil(totalItems / itemsPerPage);
+        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 = '' + pageNumber;
+            }
+            pages.push({
+                label: label,
+                value: pageNumber
+            });
+            i++;
+        }
+        return pages;
+    }
+    // Given the position in the sequence of pagination links [i], figure out what page number corresponds to that position.
+    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;
+        }
+    }
+}
+PaginationComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'co-pagination',
+                template: `
+    <div class="pagination-component-main-wrapper" *ngIf="!shouldBeHidden()">
+      <div>
+        <ng-content></ng-content>
+      </div>
+      <ul class="pagination">
+        <li *ngIf="directionLinks" class="pagination-previous">
+          <a (click)="goToPreviousPage()" [class.disabled]="isOnFirstPage()">{{ previousLabel }}</a>
+        </li>
+        <li *ngFor="let page of pages" [class.current]="getCurrentPage() === page.value" (click)="setCurrentPage(page.value)">
+          <span>{{page.label}}</span>
+        </li>
+        <li *ngIf="directionLinks" class="pagination-next">
+          <a (click)="goToNextPage()" [class.disabled]="isOnLastPage()">{{ nextLabel }}</a>
+        </li>
+      </ul>
+    </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+PaginationComponent.ctorParameters = () => [
+    { type: PaginationService }
+];
+PaginationComponent.propDecorators = {
+    template: [{ type: ViewChild, args: ['template',] }],
+    id: [{ type: Input }],
+    maxSize: [{ type: Input }],
+    directionLinks: [{ type: Input }],
+    previousLabel: [{ type: Input }],
+    nextLabel: [{ type: Input }],
+    autoHide: [{ type: Input }],
+    pageChange: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ['class.co-pagination',] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/pagination/pagination.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAET,YAAY,EAAE,WAAW,EACzB,KAAK,EAIL,MAAM,EACN,SAAS,EACT,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AA6BvD,MAAM,OAAO,mBAAmB;IAiC9B,YAAoB,kBAAqC;QAArC,uBAAkB,GAAlB,kBAAkB,CAAmB;QAzBlD,YAAO,GAAW,CAAC,CAAC;QAGpB,mBAAc,GAAY,IAAI,CAAC;QAG/B,kBAAa,GAAW,eAAe,CAAC;QAGxC,cAAS,GAAW,iBAAiB,CAAC;QAGtC,aAAQ,GAAY,KAAK,CAAC;QAEjC,6BAA6B;QAEb,eAAU,GAAyB,IAAI,YAAY,EAAU,CAAC;QAGvE,cAAS,GAAY,IAAI,CAAC;QAE1B,UAAK,GAAY,EAAE,CAAC;QAKzB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAU,EAAE,EAAE;YACvE,IAAI,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE;gBAClB,IAAI,CAAC,gBAAgB,EAAE,CAAC;aACzB;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE;YACZ,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC;SAC9C;QACD,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;IAC/B,CAAC;IAEM,aAAa;QAClB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE;YACzB,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;SACxB;IACH,CAAC;IAEM,gBAAgB;QACrB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE;YACzB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC;SAChD;IACH,CAAC;IAEM,YAAY;QACjB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE;YACxB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC;SAChD;IACH,CAAC;IAEM,cAAc,CAAC,IAAY;QAChC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAEM,aAAa;QAClB,OAAO,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;IAEM,YAAY;QACjB,OAAO,IAAI,CAAC,WAAW,EAAE,KAAK,IAAI,CAAC,cAAc,EAAE,CAAC;IACtD,CAAC;IAEM,cAAc;QACnB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,OAAO,KAAK,CAAC;SACd;aAAM;YACL,IAAI,QAAQ,GAAwB,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;YAC1E,OAAO,CAAC,QAAQ,CAAC,UAAU,IAAI,QAAQ,CAAC,YAAY,CAAC,CAAC;SACvD;IACH,CAAC;IAED;;;;OAIG;IACK,gBAAgB;QACtB,IAAI,kBAAkB,GAAwB,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC3F,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,kBAAkB,CAAC,WAAW,EAAE,kBAAkB,CAAC,YAAY,EAAE,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAEhJ,MAAM,oBAAoB,GAAW,IAAI,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,CAAC;QACnF,IAAI,oBAAoB,KAAK,kBAAkB,CAAC,WAAW,EAAE;YAC3D,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;SAC3C;IACH,CAAC;IAEM,cAAc;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACzD,CAAC;IAEO,WAAW;QACjB,IAAI,QAAQ,GAAwB,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjF,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;IAChE,CAAC;IAED;;;OAGG;IACK,oBAAoB,CAAC,QAA6B;QACxD,MAAM,UAAU,GAAW,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;QAClF,IAAI,UAAU,GAAG,QAAQ,CAAC,WAAW,IAAI,CAAC,GAAG,UAAU,EAAE;YACvD,OAAO,UAAU,CAAC;SACnB;aAAM,IAAI,QAAQ,CAAC,WAAW,GAAG,CAAC,EAAE;YACnC,OAAO,CAAC,CAAC;SACV;QAED,OAAO,QAAQ,CAAC,WAAW,CAAC;IAC9B,CAAC;IAED,uEAAuE;IAC/D,eAAe,CAAC,WAAmB,EAAE,YAAoB,EAAE,UAAkB,EAAE,eAAuB;QAC5G,iFAAiF;QACjF,eAAe,GAAG,CAAC,eAAe,CAAC;QACnC,IAAI,KAAK,GAAY,EAAE,CAAC;QACxB,MAAM,UAAU,GAAW,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC,CAAC;QAChE,MAAM,OAAO,GAAW,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC,CAAC;QACvD,MAAM,OAAO,GAAY,WAAW,IAAI,OAAO,CAAC;QAChD,MAAM,KAAK,GAAY,UAAU,GAAG,OAAO,GAAG,WAAW,CAAC;QAC1D,MAAM,QAAQ,GAAY,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC;QAC7C,IAAI,cAAc,GAAY,eAAe,GAAG,UAAU,CAAC;QAC3D,IAAI,CAAC,GAAW,CAAC,CAAC;QAClB,OAAO,CAAC,IAAI,UAAU,IAAI,CAAC,IAAI,eAAe,EAAE;YAC9C,IAAI,KAAa,CAAC;YAClB,IAAI,UAAU,GAAW,IAAI,CAAC,mBAAmB,CAAC,CAAC,EAAE,WAAW,EAAE,eAAe,EAAE,UAAU,CAAC,CAAC;YAC/F,IAAI,qBAAqB,GAAY,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC;YACtE,IAAI,qBAAqB,GAAY,CAAC,CAAC,KAAK,eAAe,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,CAAC,CAAC;YAC1F,IAAI,cAAc,IAAI,CAAC,qBAAqB,IAAI,qBAAqB,CAAC,EAAE;gBACtE,KAAK,GAAG,KAAK,CAAC;aACf;iBAAM;gBACL,KAAK,GAAG,EAAE,GAAG,UAAU,CAAC;aACzB;YACD,KAAK,CAAC,IAAI,CAAC;gBACT,KAAK,EAAE,KAAK;gBACZ,KAAK,EAAE,UAAU;aAClB,CAAC,CAAC;YACH,CAAC,EAAE,CAAC;SACL;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,wHAAwH;IAChH,mBAAmB,CAAC,CAAS,EAAE,WAAmB,EAAE,eAAuB,EAAE,UAAkB;QACrG,IAAI,OAAO,GAAW,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC,CAAC;QACrD,IAAI,CAAC,KAAK,eAAe,EAAE;YACzB,OAAO,UAAU,CAAC;SACnB;aAAM,IAAI,CAAC,KAAK,CAAC,EAAE;YAClB,OAAO,CAAC,CAAC;SACV;aAAM,IAAI,eAAe,GAAG,UAAU,EAAE;YACvC,IAAI,UAAU,GAAG,OAAO,GAAG,WAAW,EAAE;gBACtC,OAAO,UAAU,GAAG,eAAe,GAAG,CAAC,CAAC;aACzC;iBAAM,IAAI,OAAO,GAAG,WAAW,EAAE;gBAChC,OAAO,WAAW,GAAG,OAAO,GAAG,CAAC,CAAC;aAClC;iBAAM;gBACL,OAAO,CAAC,CAAC;aACV;SACF;aAAM;YACL,OAAO,CAAC,CAAC;SACV;IACH,CAAC;;;YA7MF,SAAS,SAAC;gBACT,QAAQ,EAAE,eAAe;gBACzB,QAAQ,EAAE;;;;;;;;;;;;;;;;;GAiBT;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;aACtC;;;YA5BO,iBAAiB;;;uBA8BtB,SAAS,SAAC,UAAU;iBAGpB,KAAK;sBAGL,KAAK;6BAGL,KAAK;4BAGL,KAAK;wBAGL,KAAK;uBAGL,KAAK;yBAIL,MAAM;wBAGN,WAAW,SAAC,qBAAqB","sourcesContent":["import {\r\n  Component,\r\n  ElementRef,\r\n  EventEmitter, HostBinding,\r\n  Input,\r\n  OnChanges,\r\n  OnDestroy,\r\n  OnInit,\r\n  Output,\r\n  ViewChild,\r\n  ViewEncapsulation\r\n} from '@angular/core';\r\nimport {Subscription} from 'rxjs';\r\n\r\nimport {IPaginationInstance} from './pagination-instance';\r\nimport {PaginationService} from './pagination.service';\r\n\r\nexport interface IPage {\r\n  label: string;\r\n  value: any;\r\n}\r\n\r\n@Component({\r\n  selector: 'co-pagination',\r\n  template: `\r\n    <div class=\"pagination-component-main-wrapper\" *ngIf=\"!shouldBeHidden()\">\r\n      <div>\r\n        <ng-content></ng-content>\r\n      </div>\r\n      <ul class=\"pagination\">\r\n        <li *ngIf=\"directionLinks\" class=\"pagination-previous\">\r\n          <a (click)=\"goToPreviousPage()\" [class.disabled]=\"isOnFirstPage()\">{{ previousLabel }}</a>\r\n        </li>\r\n        <li *ngFor=\"let page of pages\" [class.current]=\"getCurrentPage() === page.value\" (click)=\"setCurrentPage(page.value)\">\r\n          <span>{{page.label}}</span>\r\n        </li>\r\n        <li *ngIf=\"directionLinks\" class=\"pagination-next\">\r\n          <a (click)=\"goToNextPage()\" [class.disabled]=\"isOnLastPage()\">{{ nextLabel }}</a>\r\n        </li>\r\n      </ul>\r\n    </div>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class PaginationComponent implements OnInit, OnChanges, OnDestroy {\r\n  @ViewChild('template')\r\n  public readonly template: ElementRef;\r\n\r\n  @Input()\r\n  public id: string;\r\n\r\n  @Input()\r\n  public maxSize: number = 7;\r\n\r\n  @Input()\r\n  public directionLinks: boolean = true;\r\n\r\n  @Input()\r\n  public previousLabel: string = 'Vorige pagina';\r\n\r\n  @Input()\r\n  public nextLabel: string = 'Volgende pagina';\r\n\r\n  @Input()\r\n  public autoHide: boolean = false;\r\n\r\n  // Emits the new page number.\r\n  @Output()\r\n  public readonly pageChange: EventEmitter<number> = new EventEmitter<number>();\r\n\r\n  @HostBinding('class.co-pagination')\r\n  public showClass: boolean = true;\r\n\r\n  public pages: IPage[] = [];\r\n\r\n  private changeSub: Subscription;\r\n\r\n  constructor(private _paginationService: PaginationService) {\r\n    this.changeSub = this._paginationService.change.subscribe((id: string) => {\r\n      if (this.id === id) {\r\n        this._updatePageLinks();\r\n      }\r\n    });\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    if (!this.id) {\r\n      this.id = this._paginationService.DEFAULT_ID;\r\n    }\r\n    this._updatePageLinks();\r\n  }\r\n\r\n  ngOnChanges(): void {\r\n    this._updatePageLinks();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.changeSub.unsubscribe();\r\n  }\r\n\r\n  public goToFirstPage(): void {\r\n    if (!this.isOnFirstPage()) {\r\n      this.setCurrentPage(1);\r\n    }\r\n  }\r\n\r\n  public goToPreviousPage(): void {\r\n    if (!this.isOnFirstPage()) {\r\n      this.setCurrentPage(this.getCurrentPage() - 1);\r\n    }\r\n  }\r\n\r\n  public goToNextPage(): void {\r\n    if (!this.isOnLastPage()) {\r\n      this.setCurrentPage(this.getCurrentPage() + 1);\r\n    }\r\n  }\r\n\r\n  public setCurrentPage(page: number): void {\r\n    this.pageChange.emit(page);\r\n  }\r\n\r\n  public isOnFirstPage(): boolean {\r\n    return this.getCurrentPage() === 1;\r\n  }\r\n\r\n  public isOnLastPage(): boolean {\r\n    return this.getLastPage() === this.getCurrentPage();\r\n  }\r\n\r\n  public shouldBeHidden(): boolean {\r\n    if (!this.autoHide) {\r\n      return false;\r\n    } else {\r\n      let instance: IPaginationInstance = this._paginationService.getInstance();\r\n      return (instance.totalItems <= instance.itemsPerPage);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Updates the page links and checks that the current page is valid. Should run whenever the\r\n   * PaginationService.change stream emits a value matching the current ID, or when any of the\r\n   * input values changes.\r\n   */\r\n  private _updatePageLinks(): void {\r\n    let paginationInstance: IPaginationInstance = this._paginationService.getInstance(this.id);\r\n    this.pages = this.createPageArray(paginationInstance.currentPage, paginationInstance.itemsPerPage, paginationInstance.totalItems, this.maxSize);\r\n\r\n    const correctedCurrentPage: number = this.outOfBoundCorrection(paginationInstance);\r\n    if (correctedCurrentPage !== paginationInstance.currentPage) {\r\n      this.setCurrentPage(correctedCurrentPage);\r\n    }\r\n  }\r\n\r\n  public getCurrentPage(): number {\r\n    return this._paginationService.getCurrentPage(this.id);\r\n  }\r\n\r\n  private getLastPage(): number {\r\n    let instance: IPaginationInstance = this._paginationService.getInstance(this.id);\r\n    return Math.ceil(instance.totalItems / instance.itemsPerPage);\r\n  }\r\n\r\n  /**\r\n   * Checks that the instance.currentPage property is within bounds for the current page range.\r\n   * If not, return a correct value for currentPage, or the current value if OK.\r\n   */\r\n  private outOfBoundCorrection(instance: IPaginationInstance): number {\r\n    const totalPages: number = Math.ceil(instance.totalItems / instance.itemsPerPage);\r\n    if (totalPages < instance.currentPage && 0 < totalPages) {\r\n      return totalPages;\r\n    } else if (instance.currentPage < 1) {\r\n      return 1;\r\n    }\r\n\r\n    return instance.currentPage;\r\n  }\r\n\r\n  // Returns an array of IPage objects to use in the pagination controls.\r\n  private createPageArray(currentPage: number, itemsPerPage: number, totalItems: number, paginationRange: number): IPage[] {\r\n    // paginationRange could be a string if passed from attribute, so cast to number.\r\n    paginationRange = +paginationRange;\r\n    let pages: IPage[] = [];\r\n    const totalPages: number = Math.ceil(totalItems / itemsPerPage);\r\n    const halfWay: number = Math.ceil(paginationRange / 2);\r\n    const isStart: boolean = currentPage <= halfWay;\r\n    const isEnd: boolean = totalPages - halfWay < currentPage;\r\n    const isMiddle: boolean = !isStart && !isEnd;\r\n    let ellipsesNeeded: boolean = paginationRange < totalPages;\r\n    let i: number = 1;\r\n    while (i <= totalPages && i <= paginationRange) {\r\n      let label: string;\r\n      let pageNumber: number = this.calculatePageNumber(i, currentPage, paginationRange, totalPages);\r\n      let openingEllipsesNeeded: boolean = (i === 2 && (isMiddle || isEnd));\r\n      let closingEllipsesNeeded: boolean = (i === paginationRange - 1 && (isMiddle || isStart));\r\n      if (ellipsesNeeded && (openingEllipsesNeeded || closingEllipsesNeeded)) {\r\n        label = '...';\r\n      } else {\r\n        label = '' + pageNumber;\r\n      }\r\n      pages.push({\r\n        label: label,\r\n        value: pageNumber\r\n      });\r\n      i++;\r\n    }\r\n    return pages;\r\n  }\r\n\r\n  // Given the position in the sequence of pagination links [i], figure out what page number corresponds to that position.\r\n  private calculatePageNumber(i: number, currentPage: number, paginationRange: number, totalPages: number): number {\r\n    let halfWay: number = Math.ceil(paginationRange / 2);\r\n    if (i === paginationRange) {\r\n      return totalPages;\r\n    } else if (i === 1) {\r\n      return i;\r\n    } else if (paginationRange < totalPages) {\r\n      if (totalPages - halfWay < currentPage) {\r\n        return totalPages - paginationRange + i;\r\n      } else if (halfWay < currentPage) {\r\n        return currentPage - halfWay + i;\r\n      } else {\r\n        return i;\r\n      }\r\n    } else {\r\n      return i;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/pagination/pagination.module.js

@@ -0,0 +1,26 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { PaginationComponent } from "./pagination.component";
+import { PaginatePipe } from "./paginate.pipe";
+import { PaginationService } from "./pagination.service";
+export class PaginationModule {
+}
+PaginationModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule
+                ],
+                providers: [
+                    PaginationService
+                ],
+                declarations: [
+                    PaginationComponent,
+                    PaginatePipe
+                ],
+                exports: [
+                    PaginationComponent,
+                    PaginatePipe
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnaW5hdGlvbi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvcGFnaW5hdGlvbi9wYWdpbmF0aW9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUU3QyxPQUFPLEVBQUMsbUJBQW1CLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQztBQUMzRCxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLGlCQUFpQixFQUFDLE1BQU0sc0JBQXNCLENBQUM7QUFrQnZELE1BQU0sT0FBTyxnQkFBZ0I7OztZQWhCNUIsUUFBUSxTQUFDO2dCQUNOLE9BQU8sRUFBRTtvQkFDTCxZQUFZO2lCQUNmO2dCQUNELFNBQVMsRUFBRTtvQkFDUCxpQkFBaUI7aUJBQ3BCO2dCQUNELFlBQVksRUFBRTtvQkFDVixtQkFBbUI7b0JBQ25CLFlBQVk7aUJBQ2Y7Z0JBQ0QsT0FBTyxFQUFFO29CQUNMLG1CQUFtQjtvQkFDbkIsWUFBWTtpQkFDZjthQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gXCJAYW5ndWxhci9jb21tb25cIjtcclxuXHJcbmltcG9ydCB7UGFnaW5hdGlvbkNvbXBvbmVudH0gZnJvbSBcIi4vcGFnaW5hdGlvbi5jb21wb25lbnRcIjtcclxuaW1wb3J0IHtQYWdpbmF0ZVBpcGV9IGZyb20gXCIuL3BhZ2luYXRlLnBpcGVcIjtcclxuaW1wb3J0IHtQYWdpbmF0aW9uU2VydmljZX0gZnJvbSBcIi4vcGFnaW5hdGlvbi5zZXJ2aWNlXCI7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gICAgaW1wb3J0czogW1xyXG4gICAgICAgIENvbW1vbk1vZHVsZVxyXG4gICAgXSxcclxuICAgIHByb3ZpZGVyczogW1xyXG4gICAgICAgIFBhZ2luYXRpb25TZXJ2aWNlXHJcbiAgICBdLFxyXG4gICAgZGVjbGFyYXRpb25zOiBbXHJcbiAgICAgICAgUGFnaW5hdGlvbkNvbXBvbmVudCxcclxuICAgICAgICBQYWdpbmF0ZVBpcGVcclxuICAgIF0sXHJcbiAgICBleHBvcnRzOiBbXHJcbiAgICAgICAgUGFnaW5hdGlvbkNvbXBvbmVudCxcclxuICAgICAgICBQYWdpbmF0ZVBpcGVcclxuICAgIF1cclxufSlcclxuZXhwb3J0IGNsYXNzIFBhZ2luYXRpb25Nb2R1bGUge1xyXG59XHJcbiJdfQ==

package/esm2015/lib/components/pagination/pagination.service.js

@@ -0,0 +1,88 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { ObjectUtils } from "../../core/utils/object-utils";
+export class PaginationService {
+    constructor() {
+        this.change = new Subject();
+        this.instances = {};
+    }
+    get DEFAULT_ID() {
+        return PaginationService.DEFAULT_ID;
+    }
+    register(instance) {
+        if (!instance.id) {
+            instance.id = PaginationService.DEFAULT_ID;
+        }
+        if (!this.instances[instance.id]) {
+            this.instances[instance.id] = instance;
+            this.change.next(instance.id);
+        }
+        else {
+            let changed = this.updateInstance(instance);
+            if (changed) {
+                this.change.next(instance.id);
+            }
+        }
+    }
+    // Returns the current page number.
+    getCurrentPage(id) {
+        if (this.instances[id]) {
+            return this.instances[id].currentPage;
+        }
+    }
+    // Sets the current page number.
+    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.next(id);
+            }
+        }
+    }
+    // Sets the value of instance.totalItems
+    setTotalItems(id, totalItems) {
+        if (this.instances[id] && 0 <= totalItems) {
+            this.instances[id].totalItems = totalItems;
+            this.change.next(id);
+        }
+    }
+    // Sets the value of instance.itemsPerPage.
+    setItemsPerPage(id, itemsPerPage) {
+        if (this.instances[id]) {
+            this.instances[id].itemsPerPage = itemsPerPage;
+            this.change.next(id);
+        }
+    }
+    /**
+     * Returns a clone of the pagination instance object matching the id. If no
+     * id specified, returns the instance corresponding to the default id.
+     */
+    getInstance(id = PaginationService.DEFAULT_ID) {
+        if (this.instances[id]) {
+            return ObjectUtils.GetShallowClone(this.instances[id]);
+        }
+        return {};
+    }
+    /**
+     * Check each property of the instance and update any that have changed. Return
+     * true if any changes were made, else return 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;
+    }
+}
+PaginationService.DEFAULT_ID = "DEFAULT_PAGINATION_ID";
+PaginationService.decorators = [
+    { type: Injectable }
+];
+PaginationService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.service.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/pagination/pagination.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from \"@angular/core\";\r\nimport {Subject} from \"rxjs\";\r\n\r\nimport {IPaginationInstance} from \"./pagination-instance\";\r\nimport {ObjectUtils} from \"../../core/utils/object-utils\";\r\n\r\n@Injectable()\r\nexport class PaginationService {\r\n    private static readonly DEFAULT_ID: string = \"DEFAULT_PAGINATION_ID\";\r\n\r\n    public change: Subject<string> = new Subject<string>();\r\n\r\n    public get DEFAULT_ID(): string {\r\n        return PaginationService.DEFAULT_ID;\r\n    }\r\n\r\n    private readonly instances: { [id: string]: IPaginationInstance } = {};\r\n\r\n    constructor() {\r\n    }\r\n\r\n    public register(instance: IPaginationInstance): void {\r\n        if (!instance.id) {\r\n            instance.id = PaginationService.DEFAULT_ID;\r\n        }\r\n\r\n        if (!this.instances[instance.id]) {\r\n            this.instances[instance.id] = instance;\r\n            this.change.next(instance.id);\r\n        } else {\r\n            let changed: boolean = this.updateInstance(instance);\r\n            if (changed) {\r\n                this.change.next(instance.id);\r\n            }\r\n        }\r\n    }\r\n\r\n    // Returns the current page number.\r\n    public getCurrentPage(id: string): number {\r\n        if (this.instances[id]) {\r\n            return this.instances[id].currentPage;\r\n        }\r\n    }\r\n\r\n    // Sets the current page number.\r\n    public setCurrentPage(id: string, page: number): void {\r\n        if (this.instances[id]) {\r\n            let instance: IPaginationInstance = this.instances[id];\r\n            let maxPage: number = Math.ceil(instance.totalItems / instance.itemsPerPage);\r\n            if (page <= maxPage && 1 <= page) {\r\n                this.instances[id].currentPage = page;\r\n                this.change.next(id);\r\n            }\r\n        }\r\n    }\r\n\r\n    // Sets the value of instance.totalItems\r\n    public setTotalItems(id: string, totalItems: number): void {\r\n        if (this.instances[id] && 0 <= totalItems) {\r\n            this.instances[id].totalItems = totalItems;\r\n            this.change.next(id);\r\n        }\r\n    }\r\n\r\n    // Sets the value of instance.itemsPerPage.\r\n    public setItemsPerPage(id: string, itemsPerPage: number): void {\r\n        if (this.instances[id]) {\r\n            this.instances[id].itemsPerPage = itemsPerPage;\r\n            this.change.next(id);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns a clone of the pagination instance object matching the id. If no\r\n     * id specified, returns the instance corresponding to the default id.\r\n     */\r\n    public getInstance(id: string = PaginationService.DEFAULT_ID): IPaginationInstance {\r\n        if (this.instances[id]) {\r\n            return ObjectUtils.GetShallowClone(this.instances[id]);\r\n        }\r\n        return <IPaginationInstance>{};\r\n    }\r\n\r\n    /**\r\n     * Check each property of the instance and update any that have changed. Return\r\n     * true if any changes were made, else return false.\r\n     */\r\n    private updateInstance(instance: IPaginationInstance): boolean {\r\n        let changed: boolean = false;\r\n        for (let prop in this.instances[instance.id]) {\r\n            if (instance[prop] !== this.instances[instance.id][prop]) {\r\n                this.instances[instance.id][prop] = instance[prop];\r\n                changed = true;\r\n            }\r\n        }\r\n        return changed;\r\n    }\r\n}"]}