@energycap/components 0.42.4-esbuild.20250131-1219 → 0.42.4-esbuild.20250131-1256

package/esm2022/lib/display/table/table-master-row.component.mjs

@@ -0,0 +1,163 @@
+import { Component, Input, Output, EventEmitter, TemplateRef, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../controls/collapsible-toggle/collapsible-toggle.component";
+import * as i3 from "./table-detail-row.component";
+export class TableMasterRowComponent {
+    constructor(renderer, el, appRef) {
+        this.renderer = renderer;
+        this.el = el;
+        this.appRef = appRef;
+        /**
+         * Programmatically toggle the visibility of the detail row. Default is false.
+         */
+        this.showDetails = false;
+        /**
+         * Emits an event when the value of `showDetails` changes.
+         */
+        this.showDetailsChanged = new EventEmitter();
+    }
+    ngOnInit() {
+        if (!this.detailRowColSpan) {
+            console.error(`A value for [detailRowColSpan] is required to render a detail row correctly. This should be the number of columns TDs placed inside an tr[ecTableMasterRow].`);
+        }
+        this.parentNode = this.renderer.parentNode(this.el.nativeElement);
+        this.updateDetailRow();
+    }
+    ngOnChanges(changes) {
+        if (changes.hasDetails && !changes.hasDetails.firstChange && changes.hasDetails.currentValue !== undefined) {
+            this.updateDetailRow();
+        }
+        if (changes.showDetails && !changes.showDetails.firstChange && changes.showDetails.currentValue !== undefined) {
+            this.updateVisibility();
+        }
+    }
+    ngOnDestroy() {
+        this.removeDetailView();
+    }
+    /**
+     * When the master row has details, create the detail row and update it's visibility. If the master
+     * has no details, remove the detail row
+     */
+    updateDetailRow() {
+        if (this.hasDetails) {
+            if (!this.detailTemplate) {
+                console.error(`A value for the [detailTemplate] input is required when 'hasDetails' is true.`);
+                return;
+            }
+            // First check to see if the detailView is already present and if so, remove it so we don't get a 
+            // duplicate detail view
+            if (this.detailView !== undefined) {
+                this.removeDetailView();
+            }
+            this.detailView = this.detailRowTemplate.createEmbeddedView({});
+            //solution to allowing change detection in embedded view adapted from here:
+            //https://github.com/angular/angular/issues/42977
+            this.appRef.attachView(this.detailView);
+            this.updateVisibility();
+        }
+        else {
+            this.removeDetailView();
+        }
+    }
+    /**
+     * Show/hide the detail row
+     */
+    toggleDetails(show) {
+        this.showDetails = show;
+        this.showDetailsChanged.emit(show);
+        this.updateVisibility();
+    }
+    updateVisibility() {
+        if (this.showDetails) {
+            this.show();
+        }
+        else {
+            this.hide();
+        }
+    }
+    /**
+     * Attach the detailView the change detection tree and insert the generated html
+     * of the detail row to DOM after the host element
+     */
+    show() {
+        if (this.detailView) {
+            //The nextSibling may have changed, so update it. (This could happen if the table is embedded in a searchable table
+            //  and a search is performed)
+            this.siblingNode = this.renderer.nextSibling(this.el.nativeElement);
+            this.detailView.reattach();
+            this.detailView.detectChanges();
+            this.detailView.rootNodes.forEach(node => {
+                this.renderer.insertBefore(this.parentNode, node, this.siblingNode);
+            });
+        }
+    }
+    /**
+     * Detach the detailView from the change detection tree and remove the generated
+     * html of the detail row from the DOM
+     */
+    hide() {
+        if (this.detailView) {
+            this.detailView.detach();
+            this.removeDetailNodes();
+        }
+    }
+    /**
+     * Destroy the detailView and remove the generated html of the detail row from the DOM
+     */
+    removeDetailView() {
+        if (this.detailView) {
+            this.detailView.destroy();
+            this.removeDetailNodes();
+        }
+    }
+    /**
+     * Remove the generated html of the detail row from the DOM
+     */
+    removeDetailNodes() {
+        if (this.detailView) {
+            this.detailView.rootNodes.forEach(n => {
+                try {
+                    this.renderer.removeChild(this.parentNode, n);
+                }
+                catch (err) {
+                    // Ignore errors thrown by removing nodes that were never added to the DOM.
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TableMasterRowComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: TableMasterRowComponent, selector: "[ecTableMasterRow]", inputs: { id: "id", hasDetails: "hasDetails", showDetails: "showDetails", detailTemplate: "detailTemplate", detailContext: "detailContext", detailRowColSpan: "detailRowColSpan", detailRowClass: "detailRowClass", detailRowContentClass: "detailRowContentClass", detailRowMaxHeight: "detailRowMaxHeight", collapsibleToggleCellClass: "collapsibleToggleCellClass", hideTableMaster: "hideTableMaster" }, outputs: { showDetailsChanged: "showDetailsChanged" }, viewQueries: [{ propertyName: "detailRowTemplate", first: true, predicate: ["detailRow"], descendants: true, read: TemplateRef, static: true }], usesOnChanges: true, ngImport: i0, template: "<td *ngIf=\"!hideTableMaster\" class=\"{{collapsibleToggleCellClass}}\">\r\n  <ec-collapsible-toggle *ngIf=\"hasDetails\"\r\n                         id=\"{{id}}_toggle\"\r\n                         [expanded]=\"showDetails\"\r\n                         (expandedChange)=\"toggleDetails($event)\"></ec-collapsible-toggle>\r\n</td>\r\n<ng-content></ng-content>\r\n\r\n<ng-template #detailRow>\r\n  <tr ecTableDetailRow class=\"{{detailRowClass}}\" [contentClass]=\"detailRowContentClass\" [contentColSpan]=\"detailRowColSpan\" [maxHeight]=\"detailRowMaxHeight\">\r\n      <ng-container *ngTemplateOutlet=\"detailTemplate; context: {$implicit: detailContext}\"></ng-container>\r\n  </tr>\r\n</ng-template>", styles: ["td{width:1.5rem;padding:.25rem 0!important;vertical-align:top}td ::ng-deep+td{padding-left:0}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i2.CollapsibleToggleComponent, selector: "ec-collapsible-toggle", inputs: ["id", "expanded", "tabindex"], outputs: ["expandedChange"] }, { kind: "component", type: i3.TableDetailRowComponent, selector: "[ecTableDetailRow]", inputs: ["contentClass", "contentColSpan", "maxHeight"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TableMasterRowComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[ecTableMasterRow]', template: "<td *ngIf=\"!hideTableMaster\" class=\"{{collapsibleToggleCellClass}}\">\r\n  <ec-collapsible-toggle *ngIf=\"hasDetails\"\r\n                         id=\"{{id}}_toggle\"\r\n                         [expanded]=\"showDetails\"\r\n                         (expandedChange)=\"toggleDetails($event)\"></ec-collapsible-toggle>\r\n</td>\r\n<ng-content></ng-content>\r\n\r\n<ng-template #detailRow>\r\n  <tr ecTableDetailRow class=\"{{detailRowClass}}\" [contentClass]=\"detailRowContentClass\" [contentColSpan]=\"detailRowColSpan\" [maxHeight]=\"detailRowMaxHeight\">\r\n      <ng-container *ngTemplateOutlet=\"detailTemplate; context: {$implicit: detailContext}\"></ng-container>\r\n  </tr>\r\n</ng-template>", styles: ["td{width:1.5rem;padding:.25rem 0!important;vertical-align:top}td ::ng-deep+td{padding-left:0}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ApplicationRef }], propDecorators: { id: [{
+                type: Input
+            }], hasDetails: [{
+                type: Input
+            }], showDetails: [{
+                type: Input
+            }], detailTemplate: [{
+                type: Input
+            }], detailContext: [{
+                type: Input
+            }], detailRowColSpan: [{
+                type: Input
+            }], detailRowClass: [{
+                type: Input
+            }], detailRowContentClass: [{
+                type: Input
+            }], detailRowMaxHeight: [{
+                type: Input
+            }], collapsibleToggleCellClass: [{
+                type: Input
+            }], hideTableMaster: [{
+                type: Input
+            }], showDetailsChanged: [{
+                type: Output
+            }], detailRowTemplate: [{
+                type: ViewChild,
+                args: ['detailRow', { read: TemplateRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-master-row.component.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/display/table/table-master-row.component.ts","../../../../../../projects/components/src/lib/display/table/table-master-row.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, TemplateRef, ViewChild, ElementRef, Renderer2, EmbeddedViewRef, SimpleChanges, OnChanges, OnDestroy, OnInit, ApplicationRef } from '@angular/core';\r\n\r\n@Component({\r\n  selector: '[ecTableMasterRow]',\r\n  templateUrl: './table-master-row.component.html',\r\n  styleUrls: ['./table-master-row.component.scss']\r\n})\r\nexport class TableMasterRowComponent implements OnChanges, OnInit, OnDestroy {\r\n  /**\r\n   * Identifier to pass to the collapsible toggle\r\n   */\r\n  @Input() public id?: string;\r\n\r\n  /**\r\n   * Controls whether the table row has details and shows the collapsible toggle if it does.\r\n   */\r\n  @Input() hasDetails?: boolean;\r\n\r\n  /**\r\n   * Programmatically toggle the visibility of the detail row. Default is false.\r\n   */\r\n  @Input() showDetails = false;\r\n\r\n  /**\r\n   * Template for the detail row content. Generates an [EmbeddedViewRef](https://angular.io/api/core/EmbeddedViewRef)\r\n   * with the 'detailContext'. Required if hasDetails is true.\r\n   */\r\n  @Input() detailTemplate!: TemplateRef<any>;\r\n\r\n  /**\r\n   * Optional context bound to the 'detailTemplate'. Available in the template as the default local template `let` declaration.\r\n   * @example\r\n   * ```html\r\n   * <tr *ngFor=\"let item of items\" ecTableMasterRow [detailTemplate]=\"myDetailTemplate\" [detailContext]=\"item\">\r\n   *  ...\r\n   * </tr>\r\n   *\r\n   * <ng-template #myDetailTemplate let-item>\r\n   *  <p>{{item.comment}}</p>\r\n   * </ng-template>\r\n   */\r\n  @Input() detailContext?: any;\r\n\r\n  /**\r\n   * The number of columns in your table minus the column that is automatically added by the\r\n   * TableMasterRowComponent. Required.\r\n   */\r\n  @Input() detailRowColSpan!: number;\r\n\r\n  /**\r\n   * Space delimited string added to the class attribute of detail row TR.\r\n   */\r\n  @Input() detailRowClass?: string;\r\n\r\n  /**\r\n   * Space delimited string added to the class attribute of the TD that contains the detail row content\r\n   */\r\n  @Input() detailRowContentClass?: string;\r\n\r\n  @Input() detailRowMaxHeight?: string;\r\n\r\n  /** Space delimited string added to the class attribute of the TD that contains the collapsible toggle\r\n   *  element.\r\n   */\r\n  @Input() collapsibleToggleCellClass?: string;\r\n\r\n  /** Used to hide the cell added to the table. Useful if a table is shared between views and not all\r\n   *  support the table master scenario\r\n   */\r\n   @Input() hideTableMaster?: boolean;\r\n\r\n  /**\r\n   * Emits an event when the value of `showDetails` changes.\r\n   */\r\n  @Output() showDetailsChanged: EventEmitter<boolean> = new EventEmitter();\r\n\r\n  /**\r\n   * The template for the detail row, inserted in the DOM after the master row.\r\n   */\r\n  @ViewChild('detailRow', {read: TemplateRef, static: true}) detailRowTemplate!: TemplateRef<any>;\r\n\r\n  /**\r\n   * The view created from the `detailRow` template.\r\n   */\r\n  private detailView?: EmbeddedViewRef<any>;\r\n\r\n  /**\r\n   * The parent node of the host element.\r\n   */\r\n  private parentNode: any;\r\n\r\n  /**\r\n   * The sibling node of the host element.\r\n   */\r\n  private siblingNode: any;\r\n\r\n  constructor(private renderer: Renderer2, private el: ElementRef, private appRef: ApplicationRef) { }\r\n\r\n  ngOnInit(): void {\r\n    if (!this.detailRowColSpan) {\r\n      console.error(`A value for [detailRowColSpan] is required to render a detail row correctly. This should be the number of columns TDs placed inside an tr[ecTableMasterRow].`);\r\n    }\r\n\r\n    this.parentNode = this.renderer.parentNode(this.el.nativeElement);\r\n    this.updateDetailRow();\r\n\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes.hasDetails && !changes.hasDetails.firstChange && changes.hasDetails.currentValue !== undefined) {\r\n      this.updateDetailRow();\r\n    }\r\n\r\n    if (changes.showDetails && !changes.showDetails.firstChange && changes.showDetails.currentValue !== undefined) {\r\n      this.updateVisibility();\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.removeDetailView();\r\n  }\r\n\r\n  /**\r\n   * When the master row has details, create the detail row and update it's visibility. If the master\r\n   * has no details, remove the detail row\r\n   */\r\n  updateDetailRow(): void {\r\n    if (this.hasDetails) {\r\n      if (!this.detailTemplate) {\r\n        console.error(`A value for the [detailTemplate] input is required when 'hasDetails' is true.`);\r\n        return;\r\n      }\r\n\r\n      // First check to see if the detailView is already present and if so, remove it so we don't get a \r\n      // duplicate detail view\r\n      if (this.detailView !== undefined) {\r\n        this.removeDetailView();\r\n      }\r\n\r\n      this.detailView = this.detailRowTemplate.createEmbeddedView({});\r\n\r\n      //solution to allowing change detection in embedded view adapted from here:\r\n      //https://github.com/angular/angular/issues/42977\r\n      this.appRef.attachView(this.detailView);\r\n      this.updateVisibility();\r\n    } else {\r\n      this.removeDetailView();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Show/hide the detail row\r\n   */\r\n  toggleDetails(show: boolean): void {\r\n    this.showDetails = show;\r\n    this.showDetailsChanged.emit(show);\r\n    this.updateVisibility();\r\n  }\r\n\r\n  private updateVisibility(): void {\r\n    if (this.showDetails) {\r\n      this.show();\r\n    } else {\r\n      this.hide();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Attach the detailView the change detection tree and insert the generated html\r\n   * of the detail row to DOM after the host element\r\n   */\r\n  private show() {\r\n    if (this.detailView) {\r\n      //The nextSibling may have changed, so update it. (This could happen if the table is embedded in a searchable table\r\n      //  and a search is performed)\r\n      this.siblingNode = this.renderer.nextSibling(this.el.nativeElement);\r\n      this.detailView.reattach();\r\n      this.detailView.detectChanges();\r\n      this.detailView.rootNodes.forEach(node => {\r\n        this.renderer.insertBefore(this.parentNode, node, this.siblingNode);\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Detach the detailView from the change detection tree and remove the generated\r\n   * html of the detail row from the DOM\r\n   */\r\n  private hide() {\r\n    if (this.detailView) {\r\n      this.detailView.detach();\r\n      this.removeDetailNodes();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Destroy the detailView and remove the generated html of the detail row from the DOM\r\n   */\r\n  private removeDetailView() {\r\n    if (this.detailView) {\r\n      this.detailView.destroy();\r\n      this.removeDetailNodes();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Remove the generated html of the detail row from the DOM\r\n   */\r\n  private removeDetailNodes() {\r\n    if (this.detailView) {\r\n      this.detailView.rootNodes.forEach(n => {\r\n        try {\r\n          this.renderer.removeChild(this.parentNode, n);\r\n        } catch(err) {\r\n          // Ignore errors thrown by removing nodes that were never added to the DOM.\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n}\r\n","<td *ngIf=\"!hideTableMaster\" class=\"{{collapsibleToggleCellClass}}\">\r\n  <ec-collapsible-toggle *ngIf=\"hasDetails\"\r\n                         id=\"{{id}}_toggle\"\r\n                         [expanded]=\"showDetails\"\r\n                         (expandedChange)=\"toggleDetails($event)\"></ec-collapsible-toggle>\r\n</td>\r\n<ng-content></ng-content>\r\n\r\n<ng-template #detailRow>\r\n  <tr ecTableDetailRow class=\"{{detailRowClass}}\" [contentClass]=\"detailRowContentClass\" [contentColSpan]=\"detailRowColSpan\" [maxHeight]=\"detailRowMaxHeight\">\r\n      <ng-container *ngTemplateOutlet=\"detailTemplate; context: {$implicit: detailContext}\"></ng-container>\r\n  </tr>\r\n</ng-template>"]}

package/esm2022/lib/display/table/table-pagination.component.mjs

@@ -0,0 +1,155 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { NavGroup } from '../../controls/navigation/nav-group';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../controls/tabs/tabs.component";
+import * as i3 from "../../controls/dropdown/dropdown.component";
+export class TablePaginationComponent {
+    constructor(el) {
+        this.el = el;
+        /**
+         * Number of the current page.
+         * Initial value is 1, can be overridden to change the starting page number.
+         */
+        this.pageNumber = 1;
+        /**
+         * Maximum number of page tabs to show
+         */
+        this.maxTabs = 10;
+        /** When true the tabs and the more pages dropdown will be disabled */
+        this.disablePaginationControls = false;
+        /**
+         * Emits when the page changes.
+         *
+         * Bind to the event in a template using a function that uses the "skip" and "pageSize"
+         * properties to slice the new page from your data set.
+         *
+         * @example
+         * //.html
+         * (pageChanged)="onPageChanged($event)"
+         * //.ts
+         * public onPageChanged(event: PagingInfo) {
+         *  this.currentPageItems = this.paginatedTableItems.slice(event.skip, event.skip + event.pageSize);
+         * }
+         * //Since pageChanged doesn't emit for the initial page, onPageChanged should be manually called during initialization
+         * //using getPagingInfo:
+         * this.onPageChanged(TablePaginationComponent.getPagingInfo(this.startingPageNumber, this.pageSize));
+         */
+        this.pageChanged = new EventEmitter();
+        /**
+         * All possible items in the dropdown menu.
+         */
+        this.dropdownItems = [];
+        /**
+         * Current tabs being displayed.
+         */
+        this.currentTabs = new NavGroup();
+    }
+    ngOnChanges() {
+        if (this.totalItems === 0) {
+            this.dropdownItems = [];
+            this.currentTabs = new NavGroup();
+            return;
+        }
+        this.setDropdownItems();
+        //Find the menu item that the page corresponding to this.pageNumber lies in
+        let firstMenuItem = this.dropdownItems.find(item => {
+            return item.value.firstPage <= this.pageNumber && item.value.lastPage >= this.pageNumber;
+        });
+        if (!firstMenuItem) {
+            console.error(`Page ${this.pageNumber} does not exist. Setting the starting page number to 1.`);
+            firstMenuItem = this.dropdownItems[0];
+            this.pageNumber = 1;
+        }
+        //Set the tabs to those corresponding to the first menu item.
+        //Note that we dont emit a pageChanged event here because the consumer already knows what the first page is.
+        this.setTabs(firstMenuItem, this.pageNumber);
+    }
+    /**
+     * Given the number of a page and the pageSize, return the PagingInfo object for that page.
+     */
+    static getPagingInfo(pageNumber, pageSize) {
+        return { skip: (pageNumber - 1) * pageSize, pageSize: pageSize, pageNumber: pageNumber };
+    }
+    onItemSelected(menuItem) {
+        this.setTabs(menuItem);
+        this.onPageChange(parseInt(this.currentTabs.selected.label));
+        //focus the currently selected tab to help keyboard navigation
+        this.el.nativeElement.querySelector('.tab.active').focus();
+    }
+    /**
+     * Create a tab for each item in the range represented in the MenuItem
+     */
+    setTabs(menuItem, pageNumber) {
+        let tabItems = [];
+        for (let i = menuItem.value.firstPage; i <= menuItem.value.lastPage; i++) {
+            tabItems.push({
+                label: `${i}`,
+                disabled: this.disablePaginationControls,
+                onClick: () => { this.onPageChange(i); }
+            });
+        }
+        //if a pageNumber is provided, select the tab with that page number.
+        //otherwise, select the first tab.
+        let selectedTab = pageNumber ? tabItems.find(tab => { return parseInt(tab.label) === pageNumber; })
+            : tabItems[0];
+        this.currentTabs = new NavGroup(tabItems, selectedTab);
+    }
+    onPageChange(pageNumber) {
+        this.pageNumber = pageNumber;
+        this.pageChanged.emit(TablePaginationComponent.getPagingInfo(pageNumber, this.pageSize));
+    }
+    /**
+     * Create all the items for the dropdown menu.
+     * A dropdown item represents a page range (e.g. 1-10, 11-20, or 21-25).
+     * A single dropdown item can represent a range of up to 10 pages (the last item could have less than 10).
+     */
+    setDropdownItems() {
+        this.dropdownItems = [];
+        //find the last page
+        let dividend = Math.floor(this.totalItems / this.pageSize);
+        let remainder = this.totalItems % this.pageSize;
+        const lastPage = (remainder === 0) ? dividend : dividend + 1;
+        //keep building menu items of the form 1-10, 11-20, 21-30, etc until  
+        //end >= lastPage, which means we've found the range that contains the last page.
+        let start = 1;
+        let maxTabs = this.maxTabs || 10;
+        let end = maxTabs;
+        while (end < lastPage) {
+            this.dropdownItems.push({
+                label: `${start}-${end}`,
+                value: { firstPage: start, lastPage: end }
+            });
+            start = start + maxTabs;
+            end = end + maxTabs;
+        }
+        //add the menu item that contains the last page.
+        this.dropdownItems.push({
+            label: (start === lastPage) ? `${start}` : `${start}-${lastPage}`,
+            value: { firstPage: start, lastPage: lastPage }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TablePaginationComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: TablePaginationComponent, selector: "ec-table-pagination", inputs: { id: "id", totalItems: "totalItems", pageSize: "pageSize", pageNumber: "pageNumber", maxTabs: "maxTabs", disablePaginationControls: "disablePaginationControls" }, outputs: { pageChanged: "pageChanged" }, host: { classAttribute: "d-flex px-2 align-items-center" }, usesOnChanges: true, ngImport: i0, template: "<ec-tabs id=\"{{id}}_pages\"\r\n         class=\"my-2 is-condensed\"\r\n         [tabGroup]=\"currentTabs\"\r\n         tabStyle=\"pills\">\r\n</ec-tabs>\r\n<ec-dropdown id=\"{{id}}_morePages\"\r\n             *ngIf=\"dropdownItems.length > 1\"\r\n             class=\"my-1 ml-1\"\r\n             menuTemplateType=\"label\"\r\n             icon=\"icon-more\"\r\n             menuPosition=\"left\"\r\n             [menuMinWidth]=\"80\"\r\n             [showArrow]=\"false\"\r\n             [popupFixed]=\"true\"\r\n             [items]=\"dropdownItems\"\r\n             [disabled]=\"disablePaginationControls\"\r\n             (itemSelected)=\"onItemSelected($event)\">\r\n</ec-dropdown>", dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.TabsComponent, selector: "ec-tabs", inputs: ["id", "tabindex", "tabStyle", "tabGroup"] }, { kind: "component", type: i3.DropdownComponent, selector: "ec-dropdown", inputs: ["id", "autofocus", "status", "disabled", "label", "icon", "buttonType", "buttonAlignment", "buttonTitle", "tabindex", "showArrow", "items", "menuTemplateType", "menuTitle", "menuHeight", "menuWidth", "menuMinWidth", "menuPosition", "menuFooter", "popupFixed", "buttonCustomTemplate", "pending"], outputs: ["itemSelected", "popupOpened"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TablePaginationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-table-pagination', host: {
+                        class: 'd-flex px-2 align-items-center'
+                    }, template: "<ec-tabs id=\"{{id}}_pages\"\r\n         class=\"my-2 is-condensed\"\r\n         [tabGroup]=\"currentTabs\"\r\n         tabStyle=\"pills\">\r\n</ec-tabs>\r\n<ec-dropdown id=\"{{id}}_morePages\"\r\n             *ngIf=\"dropdownItems.length > 1\"\r\n             class=\"my-1 ml-1\"\r\n             menuTemplateType=\"label\"\r\n             icon=\"icon-more\"\r\n             menuPosition=\"left\"\r\n             [menuMinWidth]=\"80\"\r\n             [showArrow]=\"false\"\r\n             [popupFixed]=\"true\"\r\n             [items]=\"dropdownItems\"\r\n             [disabled]=\"disablePaginationControls\"\r\n             (itemSelected)=\"onItemSelected($event)\">\r\n</ec-dropdown>" }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { id: [{
+                type: Input
+            }], totalItems: [{
+                type: Input
+            }], pageSize: [{
+                type: Input
+            }], pageNumber: [{
+                type: Input
+            }], maxTabs: [{
+                type: Input
+            }], disablePaginationControls: [{
+                type: Input
+            }], pageChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-pagination.component.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/display/table/table-pagination.component.ts","../../../../../../projects/components/src/lib/display/table/table-pagination.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, ElementRef, OnChanges } from '@angular/core';\r\nimport { MenuItem } from '../../controls/menu/menu.component';\r\nimport { NavItem } from '../../controls/navigation/nav-item';\r\nimport { NavGroup } from '../../controls/navigation/nav-group';\r\n\r\nexport interface PagingInfo {\r\n  /**Number of items to skip to get to this page*/\r\n  skip: number,\r\n  /**Number of items in this page*/\r\n  pageSize: number,\r\n  /**The number of the page*/\r\n  pageNumber: number\r\n}\r\n\r\ninterface PageRange {\r\n  firstPage: number,\r\n  lastPage: number\r\n}\r\n\r\n@Component({\r\n  selector: 'ec-table-pagination',\r\n  templateUrl: './table-pagination.component.html',\r\n  host: {\r\n    class: 'd-flex px-2 align-items-center'\r\n  }\r\n})\r\nexport class TablePaginationComponent implements OnChanges {\r\n\r\n  @Input() id?: string;\r\n\r\n  /**\r\n   * Total number of rows that we need to page through.\r\n   * i.e. the sum of all rows on all pages.\r\n   */\r\n  @Input() totalItems!: number;\r\n\r\n  /**\r\n   * Max size of a page.\r\n   */\r\n  @Input() pageSize!: number;\r\n\r\n  /**\r\n   * Number of the current page.\r\n   * Initial value is 1, can be overridden to change the starting page number.\r\n   */\r\n  @Input() pageNumber: number = 1;\r\n\r\n  /**\r\n   * Maximum number of page tabs to show\r\n   */\r\n  @Input() maxTabs?: number = 10;\r\n\r\n  /** When true the tabs and the more pages dropdown will be disabled */\r\n  @Input() disablePaginationControls?: boolean = false;\r\n\r\n  /**\r\n   * Emits when the page changes.\r\n   * \r\n   * Bind to the event in a template using a function that uses the \"skip\" and \"pageSize\"\r\n   * properties to slice the new page from your data set.\r\n   * \r\n   * @example\r\n   * //.html\r\n   * (pageChanged)=\"onPageChanged($event)\"\r\n   * //.ts\r\n   * public onPageChanged(event: PagingInfo) {\r\n   *  this.currentPageItems = this.paginatedTableItems.slice(event.skip, event.skip + event.pageSize);\r\n   * }\r\n   * //Since pageChanged doesn't emit for the initial page, onPageChanged should be manually called during initialization \r\n   * //using getPagingInfo:\r\n   * this.onPageChanged(TablePaginationComponent.getPagingInfo(this.startingPageNumber, this.pageSize));\r\n   */\r\n  @Output() pageChanged: EventEmitter<PagingInfo> = new EventEmitter();\r\n\r\n  /**\r\n   * All possible items in the dropdown menu.\r\n   */\r\n  public dropdownItems: MenuItem<PageRange>[] = [];\r\n\r\n  /**\r\n   * Current tabs being displayed.\r\n   */\r\n  public currentTabs: NavGroup = new NavGroup();\r\n\r\n  constructor(private el: ElementRef) { }\r\n\r\n\r\n  ngOnChanges(): void {\r\n    if(this.totalItems === 0) {\r\n      this.dropdownItems = [];\r\n      this.currentTabs = new NavGroup();\r\n      return;\r\n    }\r\n    this.setDropdownItems();\r\n\r\n    //Find the menu item that the page corresponding to this.pageNumber lies in\r\n    let firstMenuItem = this.dropdownItems.find(item => {\r\n      return item.value!.firstPage <= this.pageNumber && item.value!.lastPage >= this.pageNumber;\r\n    });\r\n    if(!firstMenuItem) {\r\n      console.error(`Page ${this.pageNumber} does not exist. Setting the starting page number to 1.`);\r\n      firstMenuItem = this.dropdownItems[0];\r\n      this.pageNumber = 1;\r\n    }\r\n    //Set the tabs to those corresponding to the first menu item.\r\n    //Note that we dont emit a pageChanged event here because the consumer already knows what the first page is.\r\n    this.setTabs(firstMenuItem, this.pageNumber);\r\n  }\r\n\r\n  /**\r\n   * Given the number of a page and the pageSize, return the PagingInfo object for that page.\r\n   */\r\n  public static getPagingInfo(pageNumber: number, pageSize: number) {\r\n    return { skip: (pageNumber - 1)*pageSize, pageSize: pageSize, pageNumber: pageNumber };\r\n  }\r\n\r\n  public onItemSelected(menuItem: MenuItem<PageRange>) {  \r\n    this.setTabs(menuItem);\r\n    this.onPageChange(parseInt(this.currentTabs.selected!.label!));\r\n    //focus the currently selected tab to help keyboard navigation\r\n    this.el.nativeElement.querySelector('.tab.active').focus();\r\n  }\r\n\r\n  /**\r\n   * Create a tab for each item in the range represented in the MenuItem\r\n   */\r\n  private setTabs(menuItem: MenuItem<PageRange>, pageNumber?: number) {\r\n    let tabItems: NavItem[] = [];\r\n    for(let i = menuItem.value!.firstPage; i <= menuItem.value!.lastPage; i++) {\r\n      tabItems.push({\r\n        label: `${i}`,\r\n        disabled: this.disablePaginationControls,\r\n        onClick: () => {this.onPageChange(i)}\r\n      });\r\n    }\r\n    //if a pageNumber is provided, select the tab with that page number.\r\n    //otherwise, select the first tab.\r\n    let selectedTab: NavItem = pageNumber ? tabItems.find(tab => {return parseInt(tab.label!) === pageNumber})!\r\n                                          : tabItems[0];\r\n    this.currentTabs = new NavGroup(tabItems, selectedTab);\r\n  }\r\n\r\n  private onPageChange(pageNumber: number) {\r\n    this.pageNumber = pageNumber;\r\n    this.pageChanged.emit(TablePaginationComponent.getPagingInfo(pageNumber, this.pageSize))\r\n  }\r\n\r\n  /**\r\n   * Create all the items for the dropdown menu.\r\n   * A dropdown item represents a page range (e.g. 1-10, 11-20, or 21-25).\r\n   * A single dropdown item can represent a range of up to 10 pages (the last item could have less than 10).\r\n   */\r\n  private setDropdownItems() {\r\n    this.dropdownItems = [];\r\n    //find the last page\r\n    let dividend = Math.floor(this.totalItems / this.pageSize);\r\n    let remainder = this.totalItems % this.pageSize;\r\n    const lastPage = (remainder === 0) ? dividend : dividend + 1;\r\n\r\n    //keep building menu items of the form 1-10, 11-20, 21-30, etc until  \r\n    //end >= lastPage, which means we've found the range that contains the last page.\r\n    let start = 1;\r\n\r\n    let maxTabs = this.maxTabs || 10;\r\n    let end = maxTabs;\r\n\r\n    while(end < lastPage) {\r\n      this.dropdownItems.push({\r\n        label: `${start}-${end}`,\r\n        value: {firstPage: start, lastPage: end}\r\n      });\r\n      start = start + maxTabs;\r\n      end = end + maxTabs;\r\n    }\r\n    //add the menu item that contains the last page.\r\n    this.dropdownItems.push({\r\n      label: (start === lastPage) ? `${start}`: `${start}-${lastPage}`,\r\n      value: {firstPage: start, lastPage: lastPage}\r\n    });\r\n  }\r\n\r\n}","<ec-tabs id=\"{{id}}_pages\"\r\n         class=\"my-2 is-condensed\"\r\n         [tabGroup]=\"currentTabs\"\r\n         tabStyle=\"pills\">\r\n</ec-tabs>\r\n<ec-dropdown id=\"{{id}}_morePages\"\r\n             *ngIf=\"dropdownItems.length > 1\"\r\n             class=\"my-1 ml-1\"\r\n             menuTemplateType=\"label\"\r\n             icon=\"icon-more\"\r\n             menuPosition=\"left\"\r\n             [menuMinWidth]=\"80\"\r\n             [showArrow]=\"false\"\r\n             [popupFixed]=\"true\"\r\n             [items]=\"dropdownItems\"\r\n             [disabled]=\"disablePaginationControls\"\r\n             (itemSelected)=\"onItemSelected($event)\">\r\n</ec-dropdown>"]}