@clr/angular 12.0.7 → 13.0.0-next.1

package/esm2020/data/tree-view/tree.mjs

@@ -0,0 +1,91 @@
+/*
+ * 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, ContentChildren, HostListener, Input, } from '@angular/core';
+import { TreeFocusManagerService } from './tree-focus-manager.service';
+import { TREE_FEATURES_PROVIDER } from './tree-features.service';
+import { ClrTreeNode } from './tree-node';
+import * as i0 from "@angular/core";
+import * as i1 from "./tree-features.service";
+import * as i2 from "./tree-focus-manager.service";
+import * as i3 from "./recursive-children";
+import * as i4 from "@angular/common";
+export class ClrTree {
+    constructor(featuresService, focusManagerService, el) {
+        this.featuresService = featuresService;
+        this.focusManagerService = focusManagerService;
+        this.el = el;
+        this.subscriptions = [];
+        this.tabindex = 0;
+    }
+    set lazy(value) {
+        this.featuresService.eager = !value;
+    }
+    get isMultiSelectable() {
+        return this.featuresService.selectable && this.rootNodes.length > 0;
+    }
+    onFocusIn(event) {
+        if (event.target === this.el.nativeElement) {
+            // After discussing with the team, I've made it so that when the tree receives focus, the first visible node will be focused.
+            // This will prevent from the page scrolling abruptly to the first selected node if it exist in a deeply nested tree.
+            this.focusManagerService.focusFirstVisibleNode();
+            // when the first child gets focus,
+            // tree should no longer have tabindex of 0;
+            delete this.tabindex;
+        }
+    }
+    ngAfterContentInit() {
+        this.setRootNodes();
+        this.subscriptions.push(this.rootNodes.changes.subscribe(() => {
+            this.setRootNodes();
+        }));
+    }
+    setRootNodes() {
+        // if node has no parent, it's a root node
+        // for recursive tree, this.rootNodes registers also nested children
+        // so we have to use filter to extract the ones that are truly root nodes
+        this.focusManagerService.rootNodeModels = this.rootNodes.map(node => node._model).filter(node => !node.parent);
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+}
+ClrTree.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrTree, deps: [{ token: i1.TreeFeaturesService }, { token: i2.TreeFocusManagerService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+ClrTree.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrTree, selector: "clr-tree", inputs: { lazy: ["clrLazy", "lazy"] }, host: { listeners: { "focusin": "onFocusIn($event)" }, properties: { "attr.tabindex": "tabindex", "attr.role": "\"tree\"", "attr.aria-multiselectable": "isMultiSelectable" } }, providers: [TREE_FEATURES_PROVIDER, TreeFocusManagerService], queries: [{ propertyName: "rootNodes", predicate: ClrTreeNode }], ngImport: i0, template: `
+    <ng-content></ng-content>
+    <clr-recursive-children
+      *ngIf="featuresService.recursion"
+      [children]="featuresService.recursion.root"
+    ></clr-recursive-children>
+  `, isInline: true, components: [{ type: i3.RecursiveChildren, selector: "clr-recursive-children", inputs: ["parent", "children"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrTree, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-tree',
+                    template: `
+    <ng-content></ng-content>
+    <clr-recursive-children
+      *ngIf="featuresService.recursion"
+      [children]="featuresService.recursion.root"
+    ></clr-recursive-children>
+  `,
+                    providers: [TREE_FEATURES_PROVIDER, TreeFocusManagerService],
+                    host: {
+                        '[attr.tabindex]': 'tabindex',
+                        '[attr.role]': '"tree"',
+                        '[attr.aria-multiselectable]': 'isMultiSelectable',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TreeFeaturesService }, { type: i2.TreeFocusManagerService }, { type: i0.ElementRef }]; }, propDecorators: { lazy: [{
+                type: Input,
+                args: ['clrLazy']
+            }], onFocusIn: [{
+                type: HostListener,
+                args: ['focusin', ['$event']]
+            }], rootNodes: [{
+                type: ContentChildren,
+                args: [ClrTreeNode]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/emphasis/alert/alert-item.mjs

@@ -0,0 +1,43 @@
+/*
+ * 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/icon-and-types.service";
+import * as i2 from "../../icon/icon";
+export class ClrAlertItem {
+    constructor(iconService) {
+        this.iconService = iconService;
+    }
+}
+ClrAlertItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertItem, deps: [{ token: i1.AlertIconAndTypesService }], target: i0.ɵɵFactoryTarget.Component });
+ClrAlertItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrAlertItem, selector: "clr-alert-item", host: { classAttribute: "alert-item" }, ngImport: i0, template: `
+    <div class="alert-icon-wrapper">
+      <cds-icon
+        class="alert-icon"
+        [attr.shape]="iconService.alertIconShape"
+        [attr.title]="iconService.alertIconTitle"
+      ></cds-icon>
+    </div>
+    <ng-content></ng-content>
+  `, isInline: true, directives: [{ type: i2.CdsIconCustomTag, selector: "cds-icon" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-alert-item',
+                    template: `
+    <div class="alert-icon-wrapper">
+      <cds-icon
+        class="alert-icon"
+        [attr.shape]="iconService.alertIconShape"
+        [attr.title]="iconService.alertIconTitle"
+      ></cds-icon>
+    </div>
+    <ng-content></ng-content>
+  `,
+                    host: { class: 'alert-item' },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AlertIconAndTypesService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxlcnQtaXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXIvc3JjL2VtcGhhc2lzL2FsZXJ0L2FsZXJ0LWl0ZW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7Ozs7QUFpQjFDLE1BQU0sT0FBTyxZQUFZO0lBQ3ZCLFlBQW1CLFdBQXFDO1FBQXJDLGdCQUFXLEdBQVgsV0FBVyxDQUEwQjtJQUFHLENBQUM7O3lHQURqRCxZQUFZOzZGQUFaLFlBQVksOEZBWmI7Ozs7Ozs7OztHQVNUOzJGQUdVLFlBQVk7a0JBZHhCLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsUUFBUSxFQUFFOzs7Ozs7Ozs7R0FTVDtvQkFDRCxJQUFJLEVBQUUsRUFBRSxLQUFLLEVBQUUsWUFBWSxFQUFFO2lCQUM5QiIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTYtMjAyMSBWTXdhcmUsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqIFRoaXMgc29mdHdhcmUgaXMgcmVsZWFzZWQgdW5kZXIgTUlUIGxpY2Vuc2UuXG4gKiBUaGUgZnVsbCBsaWNlbnNlIGluZm9ybWF0aW9uIGNhbiBiZSBmb3VuZCBpbiBMSUNFTlNFIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHByb2plY3QuXG4gKi9cblxuaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBbGVydEljb25BbmRUeXBlc1NlcnZpY2UgfSBmcm9tICcuL3Byb3ZpZGVycy9pY29uLWFuZC10eXBlcy5zZXJ2aWNlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnY2xyLWFsZXJ0LWl0ZW0nLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxkaXYgY2xhc3M9XCJhbGVydC1pY29uLXdyYXBwZXJcIj5cbiAgICAgIDxjZHMtaWNvblxuICAgICAgICBjbGFzcz1cImFsZXJ0LWljb25cIlxuICAgICAgICBbYXR0ci5zaGFwZV09XCJpY29uU2VydmljZS5hbGVydEljb25TaGFwZVwiXG4gICAgICAgIFthdHRyLnRpdGxlXT1cImljb25TZXJ2aWNlLmFsZXJ0SWNvblRpdGxlXCJcbiAgICAgID48L2Nkcy1pY29uPlxuICAgIDwvZGl2PlxuICAgIDxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiAgYCxcbiAgaG9zdDogeyBjbGFzczogJ2FsZXJ0LWl0ZW0nIH0sXG59KVxuZXhwb3J0IGNsYXNzIENsckFsZXJ0SXRlbSB7XG4gIGNvbnN0cnVjdG9yKHB1YmxpYyBpY29uU2VydmljZTogQWxlcnRJY29uQW5kVHlwZXNTZXJ2aWNlKSB7fVxufVxuIl19

package/esm2020/emphasis/alert/alert-text.mjs

@@ -0,0 +1,22 @@
+/*
+ * 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 } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @remark
+ * This directive is used only of selectin alert text.
+ */
+export class ClrAlertText {
+}
+ClrAlertText.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertText, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ClrAlertText.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrAlertText, selector: ".alert-text", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertText, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '.alert-text',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxlcnQtdGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXIvc3JjL2VtcGhhc2lzL2FsZXJ0L2FsZXJ0LXRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRTFDOzs7R0FHRztBQUlILE1BQU0sT0FBTyxZQUFZOzt5R0FBWixZQUFZOzZGQUFaLFlBQVk7MkZBQVosWUFBWTtrQkFIeEIsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsYUFBYTtpQkFDeEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDE2LTIwMjEgVk13YXJlLCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKiBUaGlzIHNvZnR3YXJlIGlzIHJlbGVhc2VkIHVuZGVyIE1JVCBsaWNlbnNlLlxuICogVGhlIGZ1bGwgbGljZW5zZSBpbmZvcm1hdGlvbiBjYW4gYmUgZm91bmQgaW4gTElDRU5TRSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBwcm9qZWN0LlxuICovXG5cbmltcG9ydCB7IERpcmVjdGl2ZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIEByZW1hcmtcbiAqIFRoaXMgZGlyZWN0aXZlIGlzIHVzZWQgb25seSBvZiBzZWxlY3RpbiBhbGVydCB0ZXh0LlxuICovXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICcuYWxlcnQtdGV4dCcsXG59KVxuZXhwb3J0IGNsYXNzIENsckFsZXJ0VGV4dCB7fVxuIl19

package/esm2020/emphasis/alert/alert.mjs

@@ -0,0 +1,107 @@
+/*
+ * 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, EventEmitter, Input, Optional, Output } from '@angular/core';
+// providers
+import { AlertIconAndTypesService } from './providers/icon-and-types.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/icon-and-types.service";
+import * as i2 from "./providers/multi-alert.service";
+import * as i3 from "../../utils/i18n/common-strings.service";
+import * as i4 from "@angular/common";
+import * as i5 from "../../icon/icon";
+export class ClrAlert {
+    constructor(iconService, cdr, multiAlertService, commonStrings) {
+        this.iconService = iconService;
+        this.cdr = cdr;
+        this.multiAlertService = multiAlertService;
+        this.commonStrings = commonStrings;
+        this.subscriptions = [];
+        this.isSmall = false;
+        this.closable = true;
+        this.isAppLevel = false;
+        // Aria
+        this.clrCloseButtonAriaLabel = this.commonStrings.keys.alertCloseButtonAriaLabel;
+        this._closed = false;
+        this._closedChanged = new EventEmitter(false);
+    }
+    ngOnInit() {
+        if (this.multiAlertService) {
+            this.subscriptions.push(this.multiAlertService.changes.subscribe(() => {
+                this.hidden = this.multiAlertService.currentAlert !== this;
+            }));
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+    set alertType(val) {
+        this.iconService.alertType = val;
+    }
+    get alertType() {
+        return this.iconService.alertType;
+    }
+    set alertIconShape(value) {
+        this.iconService.alertIconShape = value;
+    }
+    get alertClass() {
+        return this.iconService.iconInfoFromType(this.iconService.alertType).cssClass;
+    }
+    set hidden(value) {
+        if (value !== this._hidden) {
+            this._hidden = value;
+            this.cdr.detectChanges();
+        }
+    }
+    get hidden() {
+        return this._hidden;
+    }
+    close() {
+        if (!this.closable) {
+            return;
+        }
+        this._closed = true;
+        if (this.multiAlertService) {
+            this.multiAlertService.close();
+        }
+        this._closedChanged.emit(true);
+    }
+    open() {
+        this._closed = false;
+        this._closedChanged.emit(false);
+    }
+}
+ClrAlert.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlert, deps: [{ token: i1.AlertIconAndTypesService }, { token: i0.ChangeDetectorRef }, { token: i2.MultiAlertService, optional: true }, { token: i3.ClrCommonStringsService }], target: i0.ɵɵFactoryTarget.Component });
+ClrAlert.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrAlert, selector: "clr-alert", inputs: { isSmall: ["clrAlertSizeSmall", "isSmall"], closable: ["clrAlertClosable", "closable"], isAppLevel: ["clrAlertAppLevel", "isAppLevel"], clrCloseButtonAriaLabel: "clrCloseButtonAriaLabel", _closed: ["clrAlertClosed", "_closed"], alertType: ["clrAlertType", "alertType"], alertIconShape: ["clrAlertIcon", "alertIconShape"] }, outputs: { _closedChanged: "clrAlertClosedChange" }, providers: [AlertIconAndTypesService], ngImport: i0, template: "<!--\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  -->\n\n<div\n  *ngIf=\"!_closed\"\n  class=\"alert\"\n  [ngClass]=\"alertClass\"\n  [class.alert-hidden]=\"hidden\"\n  [class.alert-sm]=\"isSmall\"\n  [class.alert-app-level]=\"isAppLevel\"\n>\n  <div class=\"alert-items\">\n    <ng-content></ng-content>\n  </div>\n  <button type=\"button\" class=\"close\" *ngIf=\"closable\" (click)=\"close()\" [attr.aria-label]=\"clrCloseButtonAriaLabel\">\n    <cds-icon shape=\"window-close\"></cds-icon>\n  </button>\n</div>\n", styles: [":host{display:block}\n"], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i5.CdsIconCustomTag, selector: "cds-icon" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlert, decorators: [{
+            type: Component,
+            args: [{ selector: 'clr-alert', providers: [AlertIconAndTypesService], styles: [':host { display: block; }'], template: "<!--\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  -->\n\n<div\n  *ngIf=\"!_closed\"\n  class=\"alert\"\n  [ngClass]=\"alertClass\"\n  [class.alert-hidden]=\"hidden\"\n  [class.alert-sm]=\"isSmall\"\n  [class.alert-app-level]=\"isAppLevel\"\n>\n  <div class=\"alert-items\">\n    <ng-content></ng-content>\n  </div>\n  <button type=\"button\" class=\"close\" *ngIf=\"closable\" (click)=\"close()\" [attr.aria-label]=\"clrCloseButtonAriaLabel\">\n    <cds-icon shape=\"window-close\"></cds-icon>\n  </button>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.AlertIconAndTypesService }, { type: i0.ChangeDetectorRef }, { type: i2.MultiAlertService, decorators: [{
+                    type: Optional
+                }] }, { type: i3.ClrCommonStringsService }]; }, propDecorators: { isSmall: [{
+                type: Input,
+                args: ['clrAlertSizeSmall']
+            }], closable: [{
+                type: Input,
+                args: ['clrAlertClosable']
+            }], isAppLevel: [{
+                type: Input,
+                args: ['clrAlertAppLevel']
+            }], clrCloseButtonAriaLabel: [{
+                type: Input
+            }], _closed: [{
+                type: Input,
+                args: ['clrAlertClosed']
+            }], _closedChanged: [{
+                type: Output,
+                args: ['clrAlertClosedChange']
+            }], alertType: [{
+                type: Input,
+                args: ['clrAlertType']
+            }], alertIconShape: [{
+                type: Input,
+                args: ['clrAlertIcon']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alert.js","sourceRoot":"","sources":["../../../../../projects/angular/src/emphasis/alert/alert.ts","../../../../../projects/angular/src/emphasis/alert/alert.html"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAqB,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAqB,MAAM,eAAe,CAAC;AAEvH,YAAY;AACZ,OAAO,EAAE,wBAAwB,EAAE,MAAM,oCAAoC,CAAC;;;;;;;AAW9E,MAAM,OAAO,QAAQ;IAGnB,YACU,WAAqC,EACrC,GAAsB,EACV,iBAAoC,EAChD,aAAsC;QAHtC,gBAAW,GAAX,WAAW,CAA0B;QACrC,QAAG,GAAH,GAAG,CAAmB;QACV,sBAAiB,GAAjB,iBAAiB,CAAmB;QAChD,kBAAa,GAAb,aAAa,CAAyB;QANxC,kBAAa,GAAmB,EAAE,CAAC;QAuBf,YAAO,GAAG,KAAK,CAAC;QACjB,aAAQ,GAAG,IAAI,CAAC;QAChB,eAAU,GAAG,KAAK,CAAC;QAE9C,OAAO;QACE,4BAAuB,GAAW,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,yBAAyB,CAAC;QAEpE,YAAO,GAAG,KAAK,CAAC;QACT,mBAAc,GAA0B,IAAI,YAAY,CAAU,KAAK,CAAC,CAAC;IAxBtG,CAAC;IAEJ,QAAQ;QACN,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC1B,IAAI,CAAC,aAAa,CAAC,IAAI,CACrB,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE;gBAC5C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,YAAY,KAAK,IAAI,CAAC;YAC7D,CAAC,CAAC,CACH,CAAC;SACH;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;IACvD,CAAC;IAYD,IACI,SAAS,CAAC,GAAW;QACvB,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,GAAG,CAAC;IACnC,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;IACpC,CAAC;IAED,IACI,cAAc,CAAC,KAAa;QAC9B,IAAI,CAAC,WAAW,CAAC,cAAc,GAAG,KAAK,CAAC;IAC1C,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC;IAChF,CAAC;IAID,IAAI,MAAM,CAAC,KAAc;QACvB,IAAI,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE;YAC1B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;SAC1B;IACH,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,OAAO;SACR;QACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC1B,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;SAChC;QACD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,IAAI;QACF,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;;qGA/EU,QAAQ;yFAAR,QAAQ,saAJR,CAAC,wBAAwB,CAAC,0BCfvC,8qBAqBA;2FDFa,QAAQ;kBANpB,SAAS;+BACE,WAAW,aACV,CAAC,wBAAwB,CAAC,UAE7B,CAAC,2BAA2B,CAAC;;0BAQlC,QAAQ;kFAkBiB,OAAO;sBAAlC,KAAK;uBAAC,mBAAmB;gBACC,QAAQ;sBAAlC,KAAK;uBAAC,kBAAkB;gBACE,UAAU;sBAApC,KAAK;uBAAC,kBAAkB;gBAGhB,uBAAuB;sBAA/B,KAAK;gBAEmB,OAAO;sBAA/B,KAAK;uBAAC,gBAAgB;gBACS,cAAc;sBAA7C,MAAM;uBAAC,sBAAsB;gBAG1B,SAAS;sBADZ,KAAK;uBAAC,cAAc;gBAUjB,cAAc;sBADjB,KAAK;uBAAC,cAAc","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 { ChangeDetectorRef, Component, EventEmitter, Input, Optional, Output, OnInit, OnDestroy } from '@angular/core';\n\n// providers\nimport { AlertIconAndTypesService } from './providers/icon-and-types.service';\nimport { MultiAlertService } from './providers/multi-alert.service';\nimport { ClrCommonStringsService } from '../../utils/i18n/common-strings.service';\nimport { Subscription } from 'rxjs';\n\n@Component({\n  selector: 'clr-alert',\n  providers: [AlertIconAndTypesService],\n  templateUrl: './alert.html',\n  styles: [':host { display: block; }'],\n})\nexport class ClrAlert implements OnInit, OnDestroy {\n  private subscriptions: Subscription[] = [];\n\n  constructor(\n    private iconService: AlertIconAndTypesService,\n    private cdr: ChangeDetectorRef,\n    @Optional() private multiAlertService: MultiAlertService,\n    private commonStrings: ClrCommonStringsService\n  ) {}\n\n  ngOnInit() {\n    if (this.multiAlertService) {\n      this.subscriptions.push(\n        this.multiAlertService.changes.subscribe(() => {\n          this.hidden = this.multiAlertService.currentAlert !== this;\n        })\n      );\n    }\n  }\n\n  ngOnDestroy() {\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n\n  @Input('clrAlertSizeSmall') isSmall = false;\n  @Input('clrAlertClosable') closable = true;\n  @Input('clrAlertAppLevel') isAppLevel = false;\n\n  // Aria\n  @Input() clrCloseButtonAriaLabel: string = this.commonStrings.keys.alertCloseButtonAriaLabel;\n\n  @Input('clrAlertClosed') _closed = false;\n  @Output('clrAlertClosedChange') _closedChanged: EventEmitter<boolean> = new EventEmitter<boolean>(false);\n\n  @Input('clrAlertType')\n  set alertType(val: string) {\n    this.iconService.alertType = val;\n  }\n\n  get alertType(): string {\n    return this.iconService.alertType;\n  }\n\n  @Input('clrAlertIcon')\n  set alertIconShape(value: string) {\n    this.iconService.alertIconShape = value;\n  }\n\n  get alertClass(): string {\n    return this.iconService.iconInfoFromType(this.iconService.alertType).cssClass;\n  }\n\n  private _hidden: boolean;\n\n  set hidden(value: boolean) {\n    if (value !== this._hidden) {\n      this._hidden = value;\n      this.cdr.detectChanges();\n    }\n  }\n\n  get hidden() {\n    return this._hidden;\n  }\n\n  close(): void {\n    if (!this.closable) {\n      return;\n    }\n    this._closed = true;\n    if (this.multiAlertService) {\n      this.multiAlertService.close();\n    }\n    this._closedChanged.emit(true);\n  }\n\n  open(): void {\n    this._closed = false;\n    this._closedChanged.emit(false);\n  }\n}\n","<!--\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  -->\n\n<div\n  *ngIf=\"!_closed\"\n  class=\"alert\"\n  [ngClass]=\"alertClass\"\n  [class.alert-hidden]=\"hidden\"\n  [class.alert-sm]=\"isSmall\"\n  [class.alert-app-level]=\"isAppLevel\"\n>\n  <div class=\"alert-items\">\n    <ng-content></ng-content>\n  </div>\n  <button type=\"button\" class=\"close\" *ngIf=\"closable\" (click)=\"close()\" [attr.aria-label]=\"clrCloseButtonAriaLabel\">\n    <cds-icon shape=\"window-close\"></cds-icon>\n  </button>\n</div>\n"]}

package/esm2020/emphasis/alert/alert.module.mjs

@@ -0,0 +1,34 @@
+/*
+ * 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 { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ClrIconModule } from '../../icon/icon.module';
+import { ClrDropdownModule } from '../../popover/dropdown/dropdown.module';
+import { ClrAlert } from './alert';
+import { ClrAlertItem } from './alert-item';
+import { ClrAlerts } from './alerts';
+import { ClrAlertsPager } from './alerts-pager';
+import { ClrAlertText } from './alert-text';
+import { infoCircleIcon, checkCircleIcon, ClarityIcons, exclamationCircleIcon, exclamationTriangleIcon, windowCloseIcon, } from '@cds/core/icon';
+import * as i0 from "@angular/core";
+export const CLR_ALERT_DIRECTIVES = [ClrAlert, ClrAlertItem, ClrAlerts, ClrAlertsPager, ClrAlertText];
+export class ClrAlertModule {
+    constructor() {
+        ClarityIcons.addIcons(checkCircleIcon, infoCircleIcon, exclamationCircleIcon, exclamationTriangleIcon, windowCloseIcon);
+    }
+}
+ClrAlertModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ClrAlertModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertModule, declarations: [ClrAlert, ClrAlertItem, ClrAlerts, ClrAlertsPager, ClrAlertText], imports: [CommonModule, ClrIconModule, ClrDropdownModule], exports: [ClrAlert, ClrAlertItem, ClrAlerts, ClrAlertsPager, ClrAlertText] });
+ClrAlertModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertModule, imports: [[CommonModule, ClrIconModule, ClrDropdownModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ClrIconModule, ClrDropdownModule],
+                    declarations: [CLR_ALERT_DIRECTIVES],
+                    exports: [CLR_ALERT_DIRECTIVES],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/emphasis/alert/alerts-pager.mjs

@@ -0,0 +1,72 @@
+/*
+ * 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, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/multi-alert.service";
+import * as i2 from "../../utils/i18n/common-strings.service";
+import * as i3 from "../../icon/icon";
+export class ClrAlertsPager {
+    constructor(multiAlertService, commonStrings) {
+        this.multiAlertService = multiAlertService;
+        this.commonStrings = commonStrings;
+        this.currentAlertChange = new EventEmitter(false);
+        this.currentAlertIndexChange = new EventEmitter();
+    }
+    /**
+     * Input/Output to support two way binding on current alert instance
+     */
+    set currentAlert(alert) {
+        if (alert) {
+            this.multiAlertService.currentAlert = alert;
+        }
+    }
+    get currentAlert() {
+        return this.multiAlertService.currentAlert;
+    }
+    /**
+     * Input/Output to support two way binding on current alert index
+     */
+    set currentAlertIndex(index) {
+        this.multiAlertService.current = index;
+    }
+    get currentAlertIndex() {
+        return this.multiAlertService.current;
+    }
+    ngOnInit() {
+        this.multiAlertServiceChanges = this.multiAlertService.changes.subscribe(index => {
+            this.currentAlertIndexChange.emit(index);
+            this.currentAlertChange.emit(this.multiAlertService.activeAlerts[index]);
+        });
+    }
+    pageUp() {
+        this.multiAlertService.next();
+    }
+    pageDown() {
+        this.multiAlertService.previous();
+    }
+    ngOnDestroy() {
+        this.multiAlertServiceChanges.unsubscribe();
+    }
+}
+ClrAlertsPager.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertsPager, deps: [{ token: i1.MultiAlertService }, { token: i2.ClrCommonStringsService }], target: i0.ɵɵFactoryTarget.Component });
+ClrAlertsPager.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrAlertsPager, selector: "clr-alerts-pager", inputs: { currentAlert: ["clrCurrentAlert", "currentAlert"], currentAlertIndex: ["clrCurrentAlertIndex", "currentAlertIndex"] }, outputs: { currentAlertChange: "clrCurrentAlertChange", currentAlertIndexChange: "clrCurrentAlertIndexChange" }, host: { properties: { "class.alerts-pager": "true" } }, ngImport: i0, template: "<!--\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  -->\n\n<div class=\"alerts-pager-control\">\n  <div class=\"alerts-page-down\">\n    <button class=\"alerts-pager-button\" (click)=\"pageDown()\">\n      <cds-icon shape=\"angle\" direction=\"left\" [attr.title]=\"commonStrings.keys.previous\"></cds-icon>\n    </button>\n  </div>\n  <div class=\"alerts-pager-text\">{{this.multiAlertService.current+1}} / {{this.multiAlertService.count}}</div>\n  <div class=\"alerts-page-up\">\n    <button class=\"alerts-pager-button\" (click)=\"pageUp()\">\n      <cds-icon shape=\"angle\" direction=\"right\" [attr.title]=\"commonStrings.keys.next\"></cds-icon>\n    </button>\n  </div>\n</div>\n", directives: [{ type: i3.CdsIconCustomTag, selector: "cds-icon" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlertsPager, decorators: [{
+            type: Component,
+            args: [{ selector: 'clr-alerts-pager', host: { '[class.alerts-pager]': 'true' }, template: "<!--\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  -->\n\n<div class=\"alerts-pager-control\">\n  <div class=\"alerts-page-down\">\n    <button class=\"alerts-pager-button\" (click)=\"pageDown()\">\n      <cds-icon shape=\"angle\" direction=\"left\" [attr.title]=\"commonStrings.keys.previous\"></cds-icon>\n    </button>\n  </div>\n  <div class=\"alerts-pager-text\">{{this.multiAlertService.current+1}} / {{this.multiAlertService.count}}</div>\n  <div class=\"alerts-page-up\">\n    <button class=\"alerts-pager-button\" (click)=\"pageUp()\">\n      <cds-icon shape=\"angle\" direction=\"right\" [attr.title]=\"commonStrings.keys.next\"></cds-icon>\n    </button>\n  </div>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.MultiAlertService }, { type: i2.ClrCommonStringsService }]; }, propDecorators: { currentAlert: [{
+                type: Input,
+                args: ['clrCurrentAlert']
+            }], currentAlertChange: [{
+                type: Output,
+                args: ['clrCurrentAlertChange']
+            }], currentAlertIndex: [{
+                type: Input,
+                args: ['clrCurrentAlertIndex']
+            }], currentAlertIndexChange: [{
+                type: Output,
+                args: ['clrCurrentAlertIndexChange']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/emphasis/alert/alerts.mjs

@@ -0,0 +1,100 @@
+/*
+ * 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, ContentChildren, EventEmitter, Input, Output, } from '@angular/core';
+import { ClrAlert } from './alert';
+import { MultiAlertService } from './providers/multi-alert.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/multi-alert.service";
+import * as i2 from "./alerts-pager";
+import * as i3 from "@angular/common";
+export class ClrAlerts {
+    constructor(multiAlertService) {
+        this.multiAlertService = multiAlertService;
+        this.subscriptions = [];
+        this.currentAlertIndexChange = new EventEmitter(false);
+        this.currentAlertChange = new EventEmitter(false);
+    }
+    set allAlerts(value) {
+        this.multiAlertService.manage(value); // provide alerts
+    }
+    /**
+     * Input/Output to support two way binding on current alert index
+     */
+    set _inputCurrentIndex(index) {
+        if (Number.isInteger(index) && index >= 0) {
+            this.multiAlertService.current = index;
+        }
+    }
+    set currentAlertIndex(index) {
+        this.multiAlertService.current = index;
+    }
+    get currentAlertIndex() {
+        return this.multiAlertService.current;
+    }
+    /**
+     * Input/Output to support two way binding on current alert instance
+     */
+    set currentAlert(alert) {
+        if (alert) {
+            this.multiAlertService.currentAlert = alert;
+        }
+    }
+    get currentAlert() {
+        return this.multiAlertService.currentAlert;
+    }
+    /**
+     * Ensure we are only dealing with alerts that have not been closed yet
+     */
+    get alerts() {
+        return this.allAlerts.filter(alert => {
+            return alert.hidden === false;
+        });
+    }
+    get currentAlertType() {
+        if (this.multiAlertService.currentAlert) {
+            return this.multiAlertService.currentAlert.alertType;
+        }
+        return '';
+    }
+    ngAfterContentInit() {
+        this.subscriptions.push(this.multiAlertService.changes.subscribe(index => {
+            this.currentAlertIndexChange.next(index);
+            this.currentAlertChange.next(this.multiAlertService.currentAlert);
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+        this.multiAlertService.destroy();
+    }
+}
+ClrAlerts.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlerts, deps: [{ token: i1.MultiAlertService }], target: i0.ɵɵFactoryTarget.Component });
+ClrAlerts.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrAlerts, selector: "clr-alerts", inputs: { _inputCurrentIndex: ["clrCurrentAlertIndex", "_inputCurrentIndex"], currentAlert: ["clrCurrentAlert", "currentAlert"] }, outputs: { currentAlertIndexChange: "clrCurrentAlertIndexChange", currentAlertChange: "clrCurrentAlertChange" }, host: { properties: { "class.alerts": "true", "class.alert-danger": "this.currentAlertType == 'danger'", "class.alert-info": "this.currentAlertType == 'info'", "class.alert-success": "this.currentAlertType == 'success'", "class.alert-warning": "this.currentAlertType == 'warning'" } }, providers: [MultiAlertService], queries: [{ propertyName: "allAlerts", predicate: ClrAlert }], ngImport: i0, template: "<!--\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  -->\n\n<clr-alerts-pager *ngIf=\"multiAlertService.count > 1\" [clrCurrentAlertIndex]=\"currentAlertIndex\"> </clr-alerts-pager>\n<ng-content select=\"clr-alert\"></ng-content>\n", styles: [":host{display:block}\n"], components: [{ type: i2.ClrAlertsPager, selector: "clr-alerts-pager", inputs: ["clrCurrentAlert", "clrCurrentAlertIndex"], outputs: ["clrCurrentAlertChange", "clrCurrentAlertIndexChange"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrAlerts, decorators: [{
+            type: Component,
+            args: [{ selector: 'clr-alerts', providers: [MultiAlertService], host: {
+                        '[class.alerts]': 'true',
+                        '[class.alert-danger]': "this.currentAlertType == 'danger'",
+                        '[class.alert-info]': "this.currentAlertType == 'info'",
+                        '[class.alert-success]': "this.currentAlertType == 'success'",
+                        '[class.alert-warning]': "this.currentAlertType == 'warning'",
+                    }, styles: [':host { display: block }'], template: "<!--\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  -->\n\n<clr-alerts-pager *ngIf=\"multiAlertService.count > 1\" [clrCurrentAlertIndex]=\"currentAlertIndex\"> </clr-alerts-pager>\n<ng-content select=\"clr-alert\"></ng-content>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.MultiAlertService }]; }, propDecorators: { allAlerts: [{
+                type: ContentChildren,
+                args: [ClrAlert]
+            }], _inputCurrentIndex: [{
+                type: Input,
+                args: ['clrCurrentAlertIndex']
+            }], currentAlertIndexChange: [{
+                type: Output,
+                args: ['clrCurrentAlertIndexChange']
+            }], currentAlert: [{
+                type: Input,
+                args: ['clrCurrentAlert']
+            }], currentAlertChange: [{
+                type: Output,
+                args: ['clrCurrentAlertChange']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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