@clr/angular 12.0.9 → 13.0.0

package/esm2020/data/datagrid/datagrid-items-trackby.mjs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Directive, Input, Optional } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/items";
+export class ClrDatagridItemsTrackBy {
+    constructor(_items) {
+        this._items = _items;
+    }
+    set trackBy(value) {
+        if (this._items) {
+            this._items.trackBy = value;
+        }
+    }
+}
+ClrDatagridItemsTrackBy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridItemsTrackBy, deps: [{ token: i1.Items, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ClrDatagridItemsTrackBy.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrDatagridItemsTrackBy, selector: "[ngForTrackBy]", inputs: { trackBy: ["ngForTrackBy", "trackBy"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridItemsTrackBy, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngForTrackBy]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Items, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { trackBy: [{
+                type: Input,
+                args: ['ngForTrackBy']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YWdyaWQtaXRlbXMtdHJhY2tieS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXIvc3JjL2RhdGEvZGF0YWdyaWQvZGF0YWdyaWQtaXRlbXMtdHJhY2tieS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFtQixNQUFNLGVBQWUsQ0FBQzs7O0FBTzVFLE1BQU0sT0FBTyx1QkFBdUI7SUFDbEMsWUFBZ0MsTUFBZ0I7UUFBaEIsV0FBTSxHQUFOLE1BQU0sQ0FBVTtJQUFHLENBQUM7SUFFcEQsSUFDSSxPQUFPLENBQUMsS0FBeUI7UUFDbkMsSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFO1lBQ2YsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFDO1NBQzdCO0lBQ0gsQ0FBQzs7b0hBUlUsdUJBQXVCO3dHQUF2Qix1QkFBdUI7MkZBQXZCLHVCQUF1QjtrQkFIbkMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO2lCQUMzQjs7MEJBRWMsUUFBUTs0Q0FHakIsT0FBTztzQkFEVixLQUFLO3VCQUFDLGNBQWMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDE2LTIwMjEgVk13YXJlLCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKiBUaGlzIHNvZnR3YXJlIGlzIHJlbGVhc2VkIHVuZGVyIE1JVCBsaWNlbnNlLlxuICogVGhlIGZ1bGwgbGljZW5zZSBpbmZvcm1hdGlvbiBjYW4gYmUgZm91bmQgaW4gTElDRU5TRSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBwcm9qZWN0LlxuICovXG5pbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0LCBPcHRpb25hbCwgVHJhY2tCeUZ1bmN0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IEl0ZW1zIH0gZnJvbSAnLi9wcm92aWRlcnMvaXRlbXMnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbbmdGb3JUcmFja0J5XScsXG59KVxuZXhwb3J0IGNsYXNzIENsckRhdGFncmlkSXRlbXNUcmFja0J5PFQgPSBhbnk+IHtcbiAgY29uc3RydWN0b3IoQE9wdGlvbmFsKCkgcHJpdmF0ZSBfaXRlbXM6IEl0ZW1zPFQ+KSB7fVxuXG4gIEBJbnB1dCgnbmdGb3JUcmFja0J5JylcbiAgc2V0IHRyYWNrQnkodmFsdWU6IFRyYWNrQnlGdW5jdGlvbjxUPikge1xuICAgIGlmICh0aGlzLl9pdGVtcykge1xuICAgICAgdGhpcy5faXRlbXMudHJhY2tCeSA9IHZhbHVlO1xuICAgIH1cbiAgfVxufVxuIl19

package/esm2020/data/datagrid/datagrid-items.mjs

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { NgForOf } from '@angular/common';
+import { Directive, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/items";
+export class ClrDatagridItems {
+    constructor(template, differs, items, vcr) {
+        this.template = template;
+        this.differs = differs;
+        this.items = items;
+        this.vcr = vcr;
+        this.differ = null;
+        this.subscriptions = [];
+        items.smartenUp();
+        this.iterableProxy = new NgForOf(this.vcr, this.template, this.differs);
+        this.subscriptions.push(items.change.subscribe(newItems => {
+            this.iterableProxy.ngForOf = newItems;
+            this.iterableProxy.ngDoCheck();
+        }));
+    }
+    set rawItems(items) {
+        this._rawItems = items ? items : []; // local copy for ngOnChange diffing
+    }
+    set trackBy(value) {
+        this.items.trackBy = value;
+        this.iterableProxy.ngForTrackBy = value;
+    }
+    ngDoCheck() {
+        if (!this.differ) {
+            this.differ = this.differs.find(this._rawItems).create(this.iterableProxy.ngForTrackBy);
+        }
+        if (this.differ) {
+            const changes = this.differ.diff(this._rawItems);
+            if (changes) {
+                // TODO: not very efficient right now,
+                // but premature optimization is the root of all evil.
+                this.items.all = this._rawItems;
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+}
+ClrDatagridItems.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridItems, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }, { token: i1.Items }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+ClrDatagridItems.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrDatagridItems, selector: "[clrDgItems][clrDgItemsOf]", inputs: { rawItems: ["clrDgItemsOf", "rawItems"], trackBy: ["clrDgItemsTrackBy", "trackBy"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridItems, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrDgItems][clrDgItemsOf]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }, { type: i1.Items }, { type: i0.ViewContainerRef }]; }, propDecorators: { rawItems: [{
+                type: Input,
+                args: ['clrDgItemsOf']
+            }], trackBy: [{
+                type: Input,
+                args: ['clrDgItemsTrackBy']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/data/datagrid/datagrid-page-size.mjs

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/page";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/common";
+export class ClrDatagridPageSize {
+    constructor(page) {
+        this.page = page;
+    }
+    ngOnInit() {
+        if (!this.pageSizeOptions || this.pageSizeOptions.length === 0) {
+            this.pageSizeOptions = [this.page.size];
+        }
+    }
+}
+ClrDatagridPageSize.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridPageSize, deps: [{ token: i1.Page }], target: i0.ɵɵFactoryTarget.Component });
+ClrDatagridPageSize.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrDatagridPageSize, selector: "clr-dg-page-size", inputs: { pageSizeOptions: ["clrPageSizeOptions", "pageSizeOptions"] }, ngImport: i0, template: `
+    <ng-content></ng-content>
+    <div class="clr-select-wrapper">
+      <select [class.clr-page-size-select]="true" [(ngModel)]="page.size">
+        <option *ngFor="let option of pageSizeOptions" [ngValue]="option">{{ option }}</option>
+      </select>
+    </div>
+  `, isInline: true, directives: [{ type: i2.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { type: i2.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridPageSize, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-dg-page-size',
+                    template: `
+    <ng-content></ng-content>
+    <div class="clr-select-wrapper">
+      <select [class.clr-page-size-select]="true" [(ngModel)]="page.size">
+        <option *ngFor="let option of pageSizeOptions" [ngValue]="option">{{ option }}</option>
+      </select>
+    </div>
+  `,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Page }]; }, propDecorators: { pageSizeOptions: [{
+                type: Input,
+                args: ['clrPageSizeOptions']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/data/datagrid/datagrid-pagination.mjs

@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Component, ContentChild, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { ClrDatagridPageSize } from './datagrid-page-size';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/page";
+import * as i2 from "../../utils/i18n/common-strings.service";
+import * as i3 from "./providers/detail.service";
+import * as i4 from "@angular/common";
+import * as i5 from "../../icon/icon";
+export class ClrDatagridPagination {
+    constructor(page, commonStrings, detailService) {
+        this.page = page;
+        this.commonStrings = commonStrings;
+        this.detailService = detailService;
+        this.currentChanged = new EventEmitter(false);
+        this.page.activated = true;
+    }
+    /**********
+     * Subscription to the Page service for page changes.
+     * Note: this only emits after the datagrid is initialized/stabalized and the page changes.
+     */
+    ngOnInit() {
+        /*
+         * Default page size is 10.
+         * The reason we set it here and not in the provider itself is because
+         * we don't want pagination if this component isn't present in the datagrid.
+         */
+        if (!this.page.size) {
+            this.page.size = 10;
+        }
+        this._pageSubscription = this.page.change.subscribe(current => this.currentChanged.emit(current));
+    }
+    ngOnDestroy() {
+        this.page.resetPageSize(true);
+        if (this._pageSubscription) {
+            this._pageSubscription.unsubscribe();
+        }
+    }
+    /**
+     * Page size
+     */
+    get pageSize() {
+        return this.page.size;
+    }
+    set pageSize(size) {
+        if (typeof size === 'number') {
+            this.page.size = size;
+        }
+    }
+    /**
+     * Total items (needed to guess the last page)
+     */
+    get totalItems() {
+        return this.page.totalItems;
+    }
+    set totalItems(total) {
+        if (typeof total === 'number') {
+            this.page.totalItems = total;
+        }
+    }
+    /**
+     * Last page
+     */
+    get lastPage() {
+        return this.page.last;
+    }
+    set lastPage(last) {
+        if (typeof last === 'number') {
+            this.page.last = last;
+        }
+    }
+    /**
+     * Current page
+     */
+    get currentPage() {
+        return this.page.current;
+    }
+    set currentPage(page) {
+        if (typeof page === 'number') {
+            this.page.current = page;
+        }
+    }
+    /**
+     * Moves to the previous page if it exists
+     */
+    previous() {
+        this.page.previous();
+    }
+    /**
+     * Moves to the next page if it exists
+     */
+    next() {
+        this.page.next();
+    }
+    /**
+     * Index of the first item displayed on the current page, starting at 0, -1 if none displayed
+     */
+    get firstItem() {
+        return this.page.firstItem;
+    }
+    /**
+     * Index of the last item displayed on the current page, starting at 0, -1 if none displayed
+     */
+    get lastItem() {
+        return this.page.lastItem;
+    }
+    /**
+     * Conditionally adds page numbers before and after the current page
+     */
+    get middlePages() {
+        const middlePages = [];
+        if (this.page.current > 1) {
+            middlePages.push(this.page.current - 1);
+        }
+        middlePages.push(this.page.current);
+        if (this.page.current < this.page.last) {
+            middlePages.push(this.page.current + 1);
+        }
+        return middlePages;
+    }
+    /**
+     * We only update the pagination's current page on blur of the input field, or
+     * when they press enter.
+     */
+    updateCurrentPage(event) {
+        const parsed = parseInt(event.target.value, 10);
+        // if the input value, is not a number, we don't update the page
+        if (!isNaN(parsed)) {
+            if (parsed < 1) {
+                this.page.current = 1;
+            }
+            else if (parsed > this.page.last) {
+                this.page.current = this.page.last;
+            }
+            else {
+                this.page.current = parsed;
+            }
+        }
+        /**
+         * Set the input's value to the new current page. This is needed because the code
+         * above may have changed the value from what the user entered in.
+         */
+        this.currentPageInputRef.nativeElement.value = this.page.current;
+    }
+}
+ClrDatagridPagination.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridPagination, deps: [{ token: i1.Page }, { token: i2.ClrCommonStringsService }, { token: i3.DetailService }], target: i0.ɵɵFactoryTarget.Component });
+ClrDatagridPagination.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrDatagridPagination, selector: "clr-dg-pagination", inputs: { disableCurrentPageInput: ["clrDgPageInputDisabled", "disableCurrentPageInput"], pageSize: ["clrDgPageSize", "pageSize"], totalItems: ["clrDgTotalItems", "totalItems"], lastPage: ["clrDgLastPage", "lastPage"], currentPage: ["clrDgPage", "currentPage"] }, outputs: { currentChanged: "clrDgPageChange" }, host: { properties: { "class.pagination": "true" } }, queries: [{ propertyName: "_pageSizeComponent", first: true, predicate: ClrDatagridPageSize, descendants: true }], viewQueries: [{ propertyName: "currentPageInputRef", first: true, predicate: ["currentPageInput"], descendants: true }], ngImport: i0, template: `
+    <ng-container *ngIf="!detailService.isOpen">
+      <div class="pagination-size" *ngIf="_pageSizeComponent">
+        <ng-content select="clr-dg-page-size"></ng-content>
+      </div>
+      <div class="pagination-description">
+        <ng-content></ng-content>
+      </div>
+      <div class="pagination-list" *ngIf="page.last > 1">
+        <button
+          type="button"
+          class="pagination-first"
+          [disabled]="page.current <= 1"
+          (click)="page.current = 1"
+          [attr.aria-label]="commonStrings.keys.firstPage"
+        >
+          <cds-icon shape="step-forward-2" direction="down"></cds-icon>
+        </button>
+        <button
+          type="button"
+          class="pagination-previous"
+          [disabled]="page.current <= 1"
+          (click)="page.current = page.current - 1"
+          [attr.aria-label]="commonStrings.keys.previousPage"
+        >
+          <cds-icon shape="angle" direction="left"></cds-icon>
+        </button>
+        <input
+          *ngIf="!disableCurrentPageInput; else readOnly"
+          #currentPageInput
+          type="text"
+          class="pagination-current clr-input"
+          [size]="page.last.toString().length"
+          [value]="page.current"
+          (keydown.enter)="updateCurrentPage($event)"
+          (blur)="updateCurrentPage($event)"
+          [attr.aria-label]="commonStrings.keys.currentPage"
+        />
+        <ng-template #readOnly>
+          <span>{{ page.current }}</span>
+        </ng-template>
+
+        &nbsp;/&nbsp;<span [attr.aria-label]="commonStrings.keys.totalPages">{{ page.last }}</span>
+        <button
+          type="button"
+          class="pagination-next"
+          [disabled]="page.current >= page.last"
+          (click)="page.current = page.current + 1"
+          [attr.aria-label]="commonStrings.keys.nextPage"
+        >
+          <cds-icon shape="angle" direction="right"></cds-icon>
+        </button>
+        <button
+          type="button"
+          class="pagination-last"
+          [disabled]="page.current >= page.last"
+          (click)="page.current = page.last"
+          [attr.aria-label]="commonStrings.keys.lastPage"
+        >
+          <cds-icon shape="step-forward-2" direction="up"></cds-icon>
+        </button>
+      </div>
+    </ng-container>
+    <ng-container *ngIf="detailService.isOpen">
+      <div class="pagination-description-compact">
+        {{ page.firstItem + 1 }}-{{ page.lastItem + 1 }} / {{ page.totalItems }}
+      </div>
+      <div class="pagination-list">
+        <button
+          type="button"
+          class="pagination-previous"
+          [disabled]="page.current <= 1"
+          (click)="page.current = page.current - 1"
+          [attr.aria-label]="commonStrings.keys.previousPage"
+        >
+          <cds-icon shape="angle" direction="left"></cds-icon>
+        </button>
+        <span>{{ page.current }}</span>
+        <button
+          type="button"
+          class="pagination-next"
+          [disabled]="page.current >= page.last"
+          (click)="page.current = page.current + 1"
+          [attr.aria-label]="commonStrings.keys.nextPage"
+        >
+          <cds-icon shape="angle" direction="right"></cds-icon>
+        </button>
+      </div>
+    </ng-container>
+  `, isInline: true, directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.CdsIconCustomTag, selector: "cds-icon" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridPagination, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-dg-pagination',
+                    template: `
+    <ng-container *ngIf="!detailService.isOpen">
+      <div class="pagination-size" *ngIf="_pageSizeComponent">
+        <ng-content select="clr-dg-page-size"></ng-content>
+      </div>
+      <div class="pagination-description">
+        <ng-content></ng-content>
+      </div>
+      <div class="pagination-list" *ngIf="page.last > 1">
+        <button
+          type="button"
+          class="pagination-first"
+          [disabled]="page.current <= 1"
+          (click)="page.current = 1"
+          [attr.aria-label]="commonStrings.keys.firstPage"
+        >
+          <cds-icon shape="step-forward-2" direction="down"></cds-icon>
+        </button>
+        <button
+          type="button"
+          class="pagination-previous"
+          [disabled]="page.current <= 1"
+          (click)="page.current = page.current - 1"
+          [attr.aria-label]="commonStrings.keys.previousPage"
+        >
+          <cds-icon shape="angle" direction="left"></cds-icon>
+        </button>
+        <input
+          *ngIf="!disableCurrentPageInput; else readOnly"
+          #currentPageInput
+          type="text"
+          class="pagination-current clr-input"
+          [size]="page.last.toString().length"
+          [value]="page.current"
+          (keydown.enter)="updateCurrentPage($event)"
+          (blur)="updateCurrentPage($event)"
+          [attr.aria-label]="commonStrings.keys.currentPage"
+        />
+        <ng-template #readOnly>
+          <span>{{ page.current }}</span>
+        </ng-template>
+
+        &nbsp;/&nbsp;<span [attr.aria-label]="commonStrings.keys.totalPages">{{ page.last }}</span>
+        <button
+          type="button"
+          class="pagination-next"
+          [disabled]="page.current >= page.last"
+          (click)="page.current = page.current + 1"
+          [attr.aria-label]="commonStrings.keys.nextPage"
+        >
+          <cds-icon shape="angle" direction="right"></cds-icon>
+        </button>
+        <button
+          type="button"
+          class="pagination-last"
+          [disabled]="page.current >= page.last"
+          (click)="page.current = page.last"
+          [attr.aria-label]="commonStrings.keys.lastPage"
+        >
+          <cds-icon shape="step-forward-2" direction="up"></cds-icon>
+        </button>
+      </div>
+    </ng-container>
+    <ng-container *ngIf="detailService.isOpen">
+      <div class="pagination-description-compact">
+        {{ page.firstItem + 1 }}-{{ page.lastItem + 1 }} / {{ page.totalItems }}
+      </div>
+      <div class="pagination-list">
+        <button
+          type="button"
+          class="pagination-previous"
+          [disabled]="page.current <= 1"
+          (click)="page.current = page.current - 1"
+          [attr.aria-label]="commonStrings.keys.previousPage"
+        >
+          <cds-icon shape="angle" direction="left"></cds-icon>
+        </button>
+        <span>{{ page.current }}</span>
+        <button
+          type="button"
+          class="pagination-next"
+          [disabled]="page.current >= page.last"
+          (click)="page.current = page.current + 1"
+          [attr.aria-label]="commonStrings.keys.nextPage"
+        >
+          <cds-icon shape="angle" direction="right"></cds-icon>
+        </button>
+      </div>
+    </ng-container>
+  `,
+                    host: { '[class.pagination]': 'true' },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Page }, { type: i2.ClrCommonStringsService }, { type: i3.DetailService }]; }, propDecorators: { _pageSizeComponent: [{
+                type: ContentChild,
+                args: [ClrDatagridPageSize]
+            }], currentPageInputRef: [{
+                type: ViewChild,
+                args: ['currentPageInput']
+            }], disableCurrentPageInput: [{
+                type: Input,
+                args: ['clrDgPageInputDisabled']
+            }], pageSize: [{
+                type: Input,
+                args: ['clrDgPageSize']
+            }], totalItems: [{
+                type: Input,
+                args: ['clrDgTotalItems']
+            }], lastPage: [{
+                type: Input,
+                args: ['clrDgLastPage']
+            }], currentPage: [{
+                type: Input,
+                args: ['clrDgPage']
+            }], currentChanged: [{
+                type: Output,
+                args: ['clrDgPageChange']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datagrid-pagination.js","sourceRoot":"","sources":["../../../../../projects/angular/src/data/datagrid/datagrid-pagination.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\nimport {\n  Component,\n  ContentChild,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  ViewChild,\n} from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { Page } from './providers/page';\nimport { ClrDatagridPageSize } from './datagrid-page-size';\nimport { ClrCommonStringsService } from '../../utils/i18n/common-strings.service';\nimport { DetailService } from './providers/detail.service';\n\n@Component({\n  selector: 'clr-dg-pagination',\n  template: `\n    <ng-container *ngIf=\"!detailService.isOpen\">\n      <div class=\"pagination-size\" *ngIf=\"_pageSizeComponent\">\n        <ng-content select=\"clr-dg-page-size\"></ng-content>\n      </div>\n      <div class=\"pagination-description\">\n        <ng-content></ng-content>\n      </div>\n      <div class=\"pagination-list\" *ngIf=\"page.last > 1\">\n        <button\n          type=\"button\"\n          class=\"pagination-first\"\n          [disabled]=\"page.current <= 1\"\n          (click)=\"page.current = 1\"\n          [attr.aria-label]=\"commonStrings.keys.firstPage\"\n        >\n          <cds-icon shape=\"step-forward-2\" direction=\"down\"></cds-icon>\n        </button>\n        <button\n          type=\"button\"\n          class=\"pagination-previous\"\n          [disabled]=\"page.current <= 1\"\n          (click)=\"page.current = page.current - 1\"\n          [attr.aria-label]=\"commonStrings.keys.previousPage\"\n        >\n          <cds-icon shape=\"angle\" direction=\"left\"></cds-icon>\n        </button>\n        <input\n          *ngIf=\"!disableCurrentPageInput; else readOnly\"\n          #currentPageInput\n          type=\"text\"\n          class=\"pagination-current clr-input\"\n          [size]=\"page.last.toString().length\"\n          [value]=\"page.current\"\n          (keydown.enter)=\"updateCurrentPage($event)\"\n          (blur)=\"updateCurrentPage($event)\"\n          [attr.aria-label]=\"commonStrings.keys.currentPage\"\n        />\n        <ng-template #readOnly>\n          <span>{{ page.current }}</span>\n        </ng-template>\n\n        &nbsp;/&nbsp;<span [attr.aria-label]=\"commonStrings.keys.totalPages\">{{ page.last }}</span>\n        <button\n          type=\"button\"\n          class=\"pagination-next\"\n          [disabled]=\"page.current >= page.last\"\n          (click)=\"page.current = page.current + 1\"\n          [attr.aria-label]=\"commonStrings.keys.nextPage\"\n        >\n          <cds-icon shape=\"angle\" direction=\"right\"></cds-icon>\n        </button>\n        <button\n          type=\"button\"\n          class=\"pagination-last\"\n          [disabled]=\"page.current >= page.last\"\n          (click)=\"page.current = page.last\"\n          [attr.aria-label]=\"commonStrings.keys.lastPage\"\n        >\n          <cds-icon shape=\"step-forward-2\" direction=\"up\"></cds-icon>\n        </button>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"detailService.isOpen\">\n      <div class=\"pagination-description-compact\">\n        {{ page.firstItem + 1 }}-{{ page.lastItem + 1 }} / {{ page.totalItems }}\n      </div>\n      <div class=\"pagination-list\">\n        <button\n          type=\"button\"\n          class=\"pagination-previous\"\n          [disabled]=\"page.current <= 1\"\n          (click)=\"page.current = page.current - 1\"\n          [attr.aria-label]=\"commonStrings.keys.previousPage\"\n        >\n          <cds-icon shape=\"angle\" direction=\"left\"></cds-icon>\n        </button>\n        <span>{{ page.current }}</span>\n        <button\n          type=\"button\"\n          class=\"pagination-next\"\n          [disabled]=\"page.current >= page.last\"\n          (click)=\"page.current = page.current + 1\"\n          [attr.aria-label]=\"commonStrings.keys.nextPage\"\n        >\n          <cds-icon shape=\"angle\" direction=\"right\"></cds-icon>\n        </button>\n      </div>\n    </ng-container>\n  `,\n  host: { '[class.pagination]': 'true' },\n})\nexport class ClrDatagridPagination implements OnDestroy, OnInit {\n  @ContentChild(ClrDatagridPageSize) _pageSizeComponent: ClrDatagridPageSize;\n  @ViewChild('currentPageInput') currentPageInputRef: ElementRef;\n\n  constructor(public page: Page, public commonStrings: ClrCommonStringsService, public detailService: DetailService) {\n    this.page.activated = true;\n  }\n\n  /**********\n   * Subscription to the Page service for page changes.\n   * Note: this only emits after the datagrid is initialized/stabalized and the page changes.\n   */\n  ngOnInit() {\n    /*\n     * Default page size is 10.\n     * The reason we set it here and not in the provider itself is because\n     * we don't want pagination if this component isn't present in the datagrid.\n     */\n    if (!this.page.size) {\n      this.page.size = 10;\n    }\n    this._pageSubscription = this.page.change.subscribe(current => this.currentChanged.emit(current));\n  }\n\n  /**\n   * Subscription to the page service changes\n   */\n  private _pageSubscription: Subscription;\n\n  ngOnDestroy() {\n    this.page.resetPageSize(true);\n    if (this._pageSubscription) {\n      this._pageSubscription.unsubscribe();\n    }\n  }\n\n  @Input('clrDgPageInputDisabled') public disableCurrentPageInput: boolean;\n\n  /**\n   * Page size\n   */\n  public get pageSize(): number | string {\n    return this.page.size;\n  }\n\n  @Input('clrDgPageSize')\n  public set pageSize(size: number | string) {\n    if (typeof size === 'number') {\n      this.page.size = size as number;\n    }\n  }\n\n  /**\n   * Total items (needed to guess the last page)\n   */\n  public get totalItems(): number | string {\n    return this.page.totalItems;\n  }\n\n  @Input('clrDgTotalItems')\n  public set totalItems(total: number | string) {\n    if (typeof total === 'number') {\n      this.page.totalItems = total as number;\n    }\n  }\n\n  /**\n   * Last page\n   */\n  public get lastPage(): number | string {\n    return this.page.last;\n  }\n\n  @Input('clrDgLastPage')\n  public set lastPage(last: number | string) {\n    if (typeof last === 'number') {\n      this.page.last = last as number;\n    }\n  }\n\n  /**\n   * Current page\n   */\n  public get currentPage(): number | string {\n    return this.page.current;\n  }\n\n  @Input('clrDgPage')\n  public set currentPage(page: number | string) {\n    if (typeof page === 'number') {\n      this.page.current = page as number;\n    }\n  }\n\n  @Output('clrDgPageChange') currentChanged = new EventEmitter<number>(false);\n\n  /**\n   * Moves to the previous page if it exists\n   */\n  public previous() {\n    this.page.previous();\n  }\n\n  /**\n   * Moves to the next page if it exists\n   */\n  public next() {\n    this.page.next();\n  }\n\n  /**\n   * Index of the first item displayed on the current page, starting at 0, -1 if none displayed\n   */\n  public get firstItem(): number {\n    return this.page.firstItem;\n  }\n\n  /**\n   * Index of the last item displayed on the current page, starting at 0, -1 if none displayed\n   */\n  public get lastItem(): number {\n    return this.page.lastItem;\n  }\n\n  /**\n   * Conditionally adds page numbers before and after the current page\n   */\n  public get middlePages(): number[] {\n    const middlePages: number[] = [];\n    if (this.page.current > 1) {\n      middlePages.push(this.page.current - 1);\n    }\n    middlePages.push(this.page.current);\n    if (this.page.current < this.page.last) {\n      middlePages.push(this.page.current + 1);\n    }\n    return middlePages;\n  }\n\n  /**\n   * We only update the pagination's current page on blur of the input field, or\n   * when they press enter.\n   */\n  public updateCurrentPage(event: any): void {\n    const parsed = parseInt(event.target.value, 10);\n\n    // if the input value, is not a number, we don't update the page\n    if (!isNaN(parsed)) {\n      if (parsed < 1) {\n        this.page.current = 1;\n      } else if (parsed > this.page.last) {\n        this.page.current = this.page.last;\n      } else {\n        this.page.current = parsed;\n      }\n    }\n\n    /**\n     * Set the input's value to the new current page. This is needed because the code\n     * above may have changed the value from what the user entered in.\n     */\n    this.currentPageInputRef.nativeElement.value = this.page.current;\n  }\n}\n"]}

package/esm2020/data/datagrid/datagrid-placeholder.mjs

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/items";
+import * as i2 from "@angular/common";
+export class ClrDatagridPlaceholder {
+    constructor(items) {
+        this.items = items;
+    }
+    /**
+     * Tests if the datagrid is empty, meaning it doesn't contain any items
+     */
+    get emptyDatagrid() {
+        return !this.items.loading && (!this.items.displayed || this.items.displayed.length === 0);
+    }
+}
+ClrDatagridPlaceholder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridPlaceholder, deps: [{ token: i1.Items }], target: i0.ɵɵFactoryTarget.Component });
+ClrDatagridPlaceholder.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrDatagridPlaceholder, selector: "clr-dg-placeholder", host: { properties: { "class.datagrid-placeholder-container": "true" } }, ngImport: i0, template: `
+    <div class="datagrid-placeholder" [class.datagrid-empty]="emptyDatagrid" role="row">
+      <div class="datagrid-placeholder-image" *ngIf="emptyDatagrid"></div>
+      <span role="gridcell"><ng-content *ngIf="emptyDatagrid"></ng-content></span>
+    </div>
+  `, isInline: true, directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDatagridPlaceholder, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-dg-placeholder',
+                    template: `
+    <div class="datagrid-placeholder" [class.datagrid-empty]="emptyDatagrid" role="row">
+      <div class="datagrid-placeholder-image" *ngIf="emptyDatagrid"></div>
+      <span role="gridcell"><ng-content *ngIf="emptyDatagrid"></ng-content></span>
+    </div>
+  `,
+                    host: { '[class.datagrid-placeholder-container]': 'true' },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Items }]; } });
+//# sourceMappingURL=data:application/json;base64,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