@huntsman-cancer-institute/dialog 12.11.9-SNAPSHOT

package/esm2015/index.js

@@ -0,0 +1,13 @@
+export { DialogModule } from './dialog.module';
+export { DialogService } from './service/dialog.service';
+export { BaseGenericContainerDialog } from './model/base-generic-container-dialog';
+export { ActionType } from './model/generic-dialog-action.model';
+export { DialogType } from './model/dialog-type.model';
+export { ConfirmType } from './model/confirm-type.model';
+export { AlertDialogComponent } from './alert/alert-dialog.component';
+export { ConfirmDialogComponent } from './confirm/confirm-dialog.component';
+export { CustomDialogComponent } from './custom/custom-dialog.component';
+export { GenericContainerDialogComponent } from './generic/generic-container-dialog.component';
+export { SaveFooterComponent } from './save-footer/save-footer.component';
+export { SpinnerDialogComponent } from './spinner/spinner-dialog.component';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/model/base-generic-container-dialog.js

@@ -0,0 +1,26 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BaseGenericContainerDialog {
+    constructor() {
+        this.showSpinner = false;
+        this.innerTitle = '';
+        this.primaryDisable = (action) => {
+            return false;
+        };
+        this.secondaryDisable = (action) => {
+            return false;
+        };
+        this.dirty = () => { return false; };
+    }
+}
+BaseGenericContainerDialog.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseGenericContainerDialog, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BaseGenericContainerDialog.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: BaseGenericContainerDialog, selector: "ng-component", inputs: { inputData: "inputData" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseGenericContainerDialog, decorators: [{
+            type: Component,
+            args: [{
+                    template: ''
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { inputData: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1nZW5lcmljLWNvbnRhaW5lci1kaWFsb2cuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AaHVudHNtYW4tY2FuY2VyLWluc3RpdHV0ZS9kaWFsb2cvIiwic291cmNlcyI6WyJtb2RlbC9iYXNlLWdlbmVyaWMtY29udGFpbmVyLWRpYWxvZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLEtBQUssRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFNL0MsTUFBTSxPQUFnQiwwQkFBMEI7SUFlNUM7UUFiTyxnQkFBVyxHQUFZLEtBQUssQ0FBQztRQUM3QixlQUFVLEdBQVcsRUFBRSxDQUFDO1FBRXZCLG1CQUFjLEdBQW1DLENBQUMsTUFBTSxFQUFFLEVBQUU7WUFDaEUsT0FBTyxLQUFLLENBQUM7UUFDakIsQ0FBQyxDQUFBO1FBRU8scUJBQWdCLEdBQW1DLENBQUMsTUFBTSxFQUFFLEVBQUU7WUFDbEUsT0FBTyxLQUFLLENBQUM7UUFDakIsQ0FBQyxDQUFBO1FBRU0sVUFBSyxHQUFrQixHQUFHLEVBQUUsR0FBRyxPQUFPLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUd0RCxDQUFDOzt3SEFoQmlCLDBCQUEwQjs0R0FBMUIsMEJBQTBCLHdGQUZsQyxFQUFFOzRGQUVNLDBCQUEwQjtrQkFIL0MsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsRUFBRTtpQkFDZjswRUFFWSxTQUFTO3NCQUFqQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb21wb25lbnQsIElucHV0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHtHREFjdGlvbn0gZnJvbSAnLi9nZW5lcmljLWRpYWxvZy1hY3Rpb24ubW9kZWwnO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgICB0ZW1wbGF0ZTogJydcclxufSlcclxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEJhc2VHZW5lcmljQ29udGFpbmVyRGlhbG9nIHtcclxuICAgIEBJbnB1dCgpIGlucHV0RGF0YTogYW55O1xyXG4gICAgcHVibGljIHNob3dTcGlubmVyOiBib29sZWFuID0gZmFsc2U7XHJcbiAgICBwdWJsaWMgaW5uZXJUaXRsZTogc3RyaW5nID0gJyc7XHJcblxyXG4gICAgcHVibGljICBwcmltYXJ5RGlzYWJsZTogKGFjdGlvbj86IEdEQWN0aW9uKSA9PiBib29sZWFuID0gKGFjdGlvbikgPT4ge1xyXG4gICAgICAgIHJldHVybiBmYWxzZTtcclxuICAgIH1cclxuXHJcbiAgICBwdWJsaWMgIHNlY29uZGFyeURpc2FibGU6IChhY3Rpb24/OiBHREFjdGlvbikgPT4gYm9vbGVhbiA9IChhY3Rpb24pID0+IHtcclxuICAgICAgICByZXR1cm4gZmFsc2U7XHJcbiAgICB9XHJcblxyXG4gICAgcHVibGljIGRpcnR5OiAoKSA9PiBib29sZWFuID0gKCkgPT4geyByZXR1cm4gZmFsc2U7IH07XHJcblxyXG4gICAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKCkge1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2015/model/confirm-type.model.js

@@ -0,0 +1,12 @@
+export var ConfirmType;
+(function (ConfirmType) {
+    ConfirmType["DELETE"] = "delete";
+    ConfirmType["DELETE_W_MESSAGE"] = "deleteMessage";
+    ConfirmType["DELETE_W_PROMPT"] = "deletePrompt";
+    ConfirmType["DISCARD"] = "discard";
+    ConfirmType["CONFIRM_AND_CLOSE"] = "confirmAndClose";
+    ConfirmType["ADD"] = "add";
+    ConfirmType["ALERT"] = "alert";
+    ConfirmType["GENERIC"] = "generic";
+})(ConfirmType || (ConfirmType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlybS10eXBlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGh1bnRzbWFuLWNhbmNlci1pbnN0aXR1dGUvZGlhbG9nLyIsInNvdXJjZXMiOlsibW9kZWwvY29uZmlybS10eXBlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE1BQU0sQ0FBTixJQUFZLFdBU1g7QUFURCxXQUFZLFdBQVc7SUFDckIsZ0NBQWlCLENBQUE7SUFDakIsaURBQWtDLENBQUE7SUFDbEMsK0NBQWdDLENBQUE7SUFDaEMsa0NBQW1CLENBQUE7SUFDbkIsb0RBQXFDLENBQUE7SUFDckMsMEJBQVcsQ0FBQTtJQUNYLDhCQUFlLENBQUE7SUFDZixrQ0FBbUIsQ0FBQTtBQUNyQixDQUFDLEVBVFcsV0FBVyxLQUFYLFdBQVcsUUFTdEIiLCJzb3VyY2VzQ29udGVudCI6WyJcclxuZXhwb3J0IGVudW0gQ29uZmlybVR5cGUge1xyXG4gIERFTEVURSA9ICdkZWxldGUnLFxyXG4gIERFTEVURV9XX01FU1NBR0UgPSAnZGVsZXRlTWVzc2FnZScsXHJcbiAgREVMRVRFX1dfUFJPTVBUID0gJ2RlbGV0ZVByb21wdCcsXHJcbiAgRElTQ0FSRCA9ICdkaXNjYXJkJyxcclxuICBDT05GSVJNX0FORF9DTE9TRSA9ICdjb25maXJtQW5kQ2xvc2UnLFxyXG4gIEFERCA9ICdhZGQnLFxyXG4gIEFMRVJUID0gJ2FsZXJ0JyxcclxuICBHRU5FUklDID0gJ2dlbmVyaWMnLFxyXG59XHJcbiJdfQ==

package/esm2015/model/dialog-type.model.js

@@ -0,0 +1,12 @@
+export var DialogType;
+(function (DialogType) {
+    DialogType["ERROR"] = "Error";
+    DialogType["WARNING"] = "Warning";
+    DialogType["ALERT"] = "Alert";
+    DialogType["SUCCESS"] = "Succeed";
+    DialogType["FAILED"] = "Failed";
+    DialogType["CONFIRM"] = "Confirm";
+    DialogType["INFO"] = "Info";
+    DialogType["VALIDATION"] = "Validation Error";
+})(DialogType || (DialogType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLXR5cGUubW9kZWwuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AaHVudHNtYW4tY2FuY2VyLWluc3RpdHV0ZS9kaWFsb2cvIiwic291cmNlcyI6WyJtb2RlbC9kaWFsb2ctdHlwZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQU4sSUFBWSxVQVNYO0FBVEQsV0FBWSxVQUFVO0lBQ2xCLDZCQUFlLENBQUE7SUFDZixpQ0FBbUIsQ0FBQTtJQUNuQiw2QkFBZSxDQUFBO0lBQ2YsaUNBQW1CLENBQUE7SUFDbkIsK0JBQWlCLENBQUE7SUFDakIsaUNBQW1CLENBQUE7SUFDbkIsMkJBQWEsQ0FBQTtJQUNiLDZDQUErQixDQUFBO0FBQ25DLENBQUMsRUFUVyxVQUFVLEtBQVYsVUFBVSxRQVNyQiIsInNvdXJjZXNDb250ZW50IjpbIlxyXG5cclxuZXhwb3J0IGVudW0gRGlhbG9nVHlwZSB7XHJcbiAgICBFUlJPUiA9ICdFcnJvcicsXHJcbiAgICBXQVJOSU5HID0gJ1dhcm5pbmcnLFxyXG4gICAgQUxFUlQgPSAnQWxlcnQnLFxyXG4gICAgU1VDQ0VTUyA9ICdTdWNjZWVkJyxcclxuICAgIEZBSUxFRCA9ICdGYWlsZWQnLFxyXG4gICAgQ09ORklSTSA9ICdDb25maXJtJyxcclxuICAgIElORk8gPSAnSW5mbycsXHJcbiAgICBWQUxJREFUSU9OID0gJ1ZhbGlkYXRpb24gRXJyb3InLFxyXG59XHJcbiJdfQ==

package/esm2015/model/generic-dialog-action.model.js

@@ -0,0 +1,6 @@
+export var ActionType;
+(function (ActionType) {
+    ActionType["PRIMARY"] = "primary";
+    ActionType["SECONDARY"] = "accent";
+})(ActionType || (ActionType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJpYy1kaWFsb2ctYWN0aW9uLm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGh1bnRzbWFuLWNhbmNlci1pbnN0aXR1dGUvZGlhbG9nLyIsInNvdXJjZXMiOlsibW9kZWwvZ2VuZXJpYy1kaWFsb2ctYWN0aW9uLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sQ0FBTixJQUFZLFVBR1g7QUFIRCxXQUFZLFVBQVU7SUFDbEIsaUNBQW1CLENBQUE7SUFDbkIsa0NBQW9CLENBQUE7QUFDeEIsQ0FBQyxFQUhXLFVBQVUsS0FBVixVQUFVLFFBR3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtNYXREaWFsb2dSZWZ9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2RpYWxvZyc7XHJcbmltcG9ydCB7Rm9ybUdyb3VwfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XHJcblxyXG5leHBvcnQgZW51bSBBY3Rpb25UeXBlIHtcclxuICAgIFBSSU1BUlkgPSAncHJpbWFyeScsXHJcbiAgICBTRUNPTkRBUlkgPSAnYWNjZW50J1xyXG59XHJcbmV4cG9ydCBpbnRlcmZhY2UgR0RBY3Rpb25Db25maWcge1xyXG4gICAgZm9ybVNvdXJjZT86IEZvcm1Hcm91cDtcclxuICAgIGFjdGlvbnM6IEdEQWN0aW9uW107XHJcbn1cclxuZXhwb3J0IGludGVyZmFjZSBHREFjdGlvbiB7XHJcbiAgICB0eXBlOiBBY3Rpb25UeXBlO1xyXG4gICAgaW50ZXJuYWxBY3Rpb24/OiBzdHJpbmc7XHJcbiAgICBpbnRlcm5hbEFjdGlvblJldHVyblZhbHVlPzogYm9vbGVhbiB8IGFueTtcclxuICAgIGV4dGVybmFsQWN0aW9uPzogKGRpYWxvZ1JlZj86IE1hdERpYWxvZ1JlZjxhbnk+KSA9PiB2b2lkIHwgc3RyaW5nO1xyXG4gICAgaWNvbj86IHN0cmluZztcclxuICAgIG5hbWU6IHN0cmluZztcclxuXHJcbn1cclxuIl19

package/esm2015/save-footer/save-footer.component.js

@@ -0,0 +1,135 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { DialogService } from '../service/dialog.service';
+import { ActionType } from '../model/generic-dialog-action.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../service/dialog.service";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/common";
+export class SaveFooterComponent {
+    constructor(dialogService) {
+        this.dialogService = dialogService;
+        this.actionType = ActionType.PRIMARY;
+        this.message = 'Your changes have not been saved';
+        this.name = 'Save';
+        this.disableSave = false;
+        this.saveClicked = new EventEmitter();
+        this.type = ActionType;
+    }
+    set dirty(data) {
+        if (data) {
+            this._dirty = data;
+        }
+        else {
+            this._dirty = false;
+        }
+    }
+    get dirty() {
+        return this._dirty;
+    }
+    set showSpinner(showSpinner) {
+        setTimeout(() => {
+            if (showSpinner) {
+                this.dialogService.startDefaultSpinnerDialog();
+            }
+            else {
+                this.dialogService.stopAllSpinnerDialogs();
+            }
+        });
+    }
+    ngOnInit() {
+        // console.log(this.disableSave);
+    }
+    notifySave() {
+        this.saveClicked.emit();
+    }
+    ngOnDestroy() {
+        this.saveClicked.unsubscribe();
+    }
+}
+SaveFooterComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SaveFooterComponent, deps: [{ token: i1.DialogService }], target: i0.ɵɵFactoryTarget.Component });
+SaveFooterComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: SaveFooterComponent, selector: "hci-save-footer", inputs: { actionType: "actionType", icon: "icon", message: "message", name: "name", dirty: "dirty", showSpinner: "showSpinner", disableSave: "disableSave" }, outputs: { saveClicked: "saveClicked" }, ngImport: i0, template: `
+        <div class="full-height full-width" style="margin-bottom: 8px;">
+            <div class="d-flex flex-row align-items-center right-align padded">
+                <div *ngIf="dirty" class="warning-background padded">
+                    {{ message }}
+                </div>
+                <div class="major-left-right-margin">
+                    <button mat-raised-button [disabled]="disableSave"
+                            [color]="actionType" (click)="notifySave()"
+                            [ngClass]="{'primary-action': actionType === type.PRIMARY,
+                                        'secondary-action': actionType === type.SECONDARY && !disableSave }">
+                        <img *ngIf="icon" [src]="icon" alt="">
+                        {{ name }}
+                    </button>
+                </div>
+            </div>
+        </div>
+    `, isInline: true, styles: ["\n        .primary-action{\n            background-color: #0077B3FF;\n            font-weight: bolder;\n            color: white;\n        }\n        .secondary-action{\n            background-color: #DEF4FFFF;\n            font-weight: bolder;\n            color: #0077B3FF;\n            border: #0077B3FF  solid 1px;\n        }\n\n        .major-left-right-margin {\n            margin-left:  0.5em;\n            margin-right: 0.5em;\n        }\n\n        .right-align {\n            text-align: right;\n            justify-content: flex-end;\n        }\n\n\n        .warning-background { background:#feec89; }\n\n    "], components: [{ type: i2.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SaveFooterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'hci-save-footer',
+                    template: `
+        <div class="full-height full-width" style="margin-bottom: 8px;">
+            <div class="d-flex flex-row align-items-center right-align padded">
+                <div *ngIf="dirty" class="warning-background padded">
+                    {{ message }}
+                </div>
+                <div class="major-left-right-margin">
+                    <button mat-raised-button [disabled]="disableSave"
+                            [color]="actionType" (click)="notifySave()"
+                            [ngClass]="{'primary-action': actionType === type.PRIMARY,
+                                        'secondary-action': actionType === type.SECONDARY && !disableSave }">
+                        <img *ngIf="icon" [src]="icon" alt="">
+                        {{ name }}
+                    </button>
+                </div>
+            </div>
+        </div>
+    `,
+                    styles: [`
+        .primary-action{
+            background-color: #0077B3FF;
+            font-weight: bolder;
+            color: white;
+        }
+        .secondary-action{
+            background-color: #DEF4FFFF;
+            font-weight: bolder;
+            color: #0077B3FF;
+            border: #0077B3FF  solid 1px;
+        }
+
+        .major-left-right-margin {
+            margin-left:  0.5em;
+            margin-right: 0.5em;
+        }
+
+        .right-align {
+            text-align: right;
+            justify-content: flex-end;
+        }
+
+
+        .warning-background { background:#feec89; }
+
+    `]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DialogService }]; }, propDecorators: { actionType: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], message: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], dirty: [{
+                type: Input
+            }], showSpinner: [{
+                type: Input
+            }], disableSave: [{
+                type: Input
+            }], saveClicked: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/service/dialog.service.js

@@ -0,0 +1,272 @@
+import { Injectable } from '@angular/core';
+import { MatDialog, MatDialogConfig } from '@angular/material/dialog';
+import { AlertDialogComponent } from '../alert/alert-dialog.component';
+import { SpinnerDialogComponent } from '../spinner/spinner-dialog.component';
+import { CustomDialogComponent } from '../custom/custom-dialog.component';
+import { GenericContainerDialogComponent } from '../generic/generic-container-dialog.component';
+import { ActionType } from '../model/generic-dialog-action.model';
+import { DialogType } from '../model/dialog-type.model';
+import { ConfirmType } from '../model/confirm-type.model';
+import { ConfirmDialogComponent } from '../confirm/confirm-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+export class DialogService {
+    constructor(dialog) {
+        this.dialog = dialog;
+        this._spinnerDialogIsOpen = false;
+        this.spinnerWorkItemCount = 0;
+        this.checkingSpinnerWorkItems = false;
+        this.spinnerDialogRefs = [];
+    }
+    get spinnerDialogIsOpen() {
+        return this._spinnerDialogIsOpen;
+    }
+    alert(message, title, dialogType, icon, config) {
+        return this.openDialog(message, title, dialogType ? dialogType : DialogType.ALERT, icon, config);
+    }
+    confirm(message, title, icon, config) {
+        return this.openDialog(message, title, DialogType.CONFIRM, icon, config);
+    }
+    /**
+     * Creates a ConfirmDialogComponent with different display depending on
+     * the ConfirmType.
+     * @param title defaults to 'Confirm'
+     * @param icon defaults to 'fa fa-info-circle'
+     * @param config config.data can contain a prompt, message1 and/or
+     * message2 according to the ConfirmType chosen
+     * @param actionConfig sets up the dialog buttons and actions if you want
+     * to override the defaults
+     */
+    confirmByType(confirmType, title, icon, config, actionConfig) {
+        if (!title) {
+            title = 'Confirm';
+        }
+        if (!icon) {
+            icon = 'fa fa-info-circle';
+        }
+        // set up a default if needed
+        if (!config) {
+            config = new MatDialogConfig();
+            config.width = '33vw';
+            config.minWidth = '300px';
+            config.disableClose = true;
+        }
+        if (config.data) {
+            config.data.confirmType = confirmType;
+        }
+        else {
+            config.data = {
+                confirmType
+            };
+        }
+        // if no actions passed in, set up the defaults
+        if (!actionConfig) {
+            // default actions
+            let primary = { type: ActionType.PRIMARY, name: 'YES',
+                internalAction: 'onConfirmClick', internalActionReturnValue: true };
+            let secondary = { type: ActionType.SECONDARY, name: 'GO BACK',
+                internalAction: 'onClose' };
+            // by enum type, setup the messages/prompt
+            // only two need different defaults than generic defaults
+            switch (confirmType) {
+                case ConfirmType.CONFIRM_AND_CLOSE:
+                    primary = { type: ActionType.PRIMARY, name: 'CONFIRM AND CLOSE',
+                        internalAction: 'onConfirmClick', internalActionReturnValue: true };
+                    break;
+                case ConfirmType.ALERT:
+                    primary = undefined;
+                    secondary = { type: ActionType.SECONDARY, name: 'CLOSE',
+                        internalAction: 'onClose' };
+                    break;
+                // case ConfirmType.DELETE:
+                // case ConfirmType.DELETE_W_MESSAGE:
+                // case ConfirmType.DELETE_W_PROMPT:
+                // case ConfirmType.DISCARD:
+                // case ConfirmType.ADD:
+                // case ConfirmType.GENERIC:
+                default:
+                    throw new Error('Confirm type doesn\'t exist');
+            }
+            const actions = [];
+            if (primary) {
+                actions.push(primary);
+            }
+            if (secondary) {
+                actions.push(secondary);
+            }
+            actionConfig = {
+                actions
+            };
+        }
+        return this.genericDialogContainer(ConfirmDialogComponent, title, icon, config, actionConfig);
+    }
+    error(message, title, icon, config) {
+        return this.openDialog(message, title, DialogType.ERROR, icon, config);
+    }
+    info(message, title, icon, config) {
+        return this.openDialog(message, title, DialogType.INFO, icon, config);
+    }
+    createCustomDialog(tempRef, context, title, icon, config, actionConfig) {
+        let configuration = null;
+        if (!config) {
+            configuration = new MatDialogConfig();
+        }
+        else {
+            configuration = config;
+        }
+        configuration.data = configuration.data ? configuration.data : {};
+        configuration.data.templateRef = tempRef;
+        configuration.data.title = title ? title : '';
+        configuration.data.icon = icon ? icon : '';
+        configuration.data.context = context;
+        if (actionConfig) {
+            configuration.data.actionConfig = actionConfig;
+        }
+        configuration.minWidth = configuration.minWidth ? configuration.minWidth : '10em';
+        configuration.width = configuration.width ? configuration.width : '30em';
+        configuration.panelClass = ['mx-sized-dialog', 'no-padding'];
+        configuration.disableClose = true;
+        configuration.hasBackdrop = true;
+        const dialogRef = this.dialog.open(CustomDialogComponent, configuration);
+        return dialogRef;
+    }
+    startDefaultSpinnerDialog() {
+        return this.startSpinnerDialog('Please wait...', 3, 30);
+    }
+    startSpinnerDialog(message, strokeWidth, diameter) {
+        if (this._spinnerDialogIsOpen) {
+            return null;
+        }
+        this._spinnerDialogIsOpen = true;
+        const configuration = new MatDialogConfig();
+        configuration.data = {
+            message,
+            strokeWidth,
+            diameter
+        };
+        configuration.width = '13em';
+        configuration.disableClose = true;
+        const dialogRef = this.dialog.open(SpinnerDialogComponent, configuration);
+        dialogRef.afterClosed().subscribe(() => {
+            this._spinnerDialogIsOpen = false;
+        });
+        this.spinnerDialogRefs.push(dialogRef);
+        return dialogRef;
+    }
+    startNonModalSpinnerDialog(message, strokeWidth, diameter) {
+        if (this._spinnerDialogIsOpen) {
+            return null;
+        }
+        this._spinnerDialogIsOpen = true;
+        const configuration = new MatDialogConfig();
+        configuration.data = {
+            message,
+            strokeWidth,
+            diameter
+        };
+        configuration.width = '13em';
+        configuration.disableClose = true;
+        configuration.hasBackdrop = false;
+        const dialogRef = this.dialog.open(SpinnerDialogComponent, configuration);
+        dialogRef.afterClosed().subscribe(() => {
+            this._spinnerDialogIsOpen = false;
+        });
+        this.spinnerDialogRefs.push(dialogRef);
+        return dialogRef;
+    }
+    // Let there be an alternative, global way to stop all active spinner dialogs.
+    stopAllSpinnerDialogs() {
+        this.spinnerWorkItemCount = 0;
+        for (const dialogRef of this.spinnerDialogRefs) {
+            setTimeout(() => {
+                dialogRef.close();
+            });
+        }
+        this.spinnerDialogRefs = [];
+    }
+    addSpinnerWorkItem() {
+        this.spinnerWorkItemCount++;
+        if (!this.checkingSpinnerWorkItems) {
+            this.checkingSpinnerWorkItems = true;
+            setTimeout(() => {
+                this.checkSpinnerWorkItems();
+            });
+        }
+    }
+    removeSpinnerWorkItem() {
+        this.spinnerWorkItemCount--;
+        if (this.spinnerWorkItemCount < 0) {
+            this.spinnerWorkItemCount = 0;
+        }
+        if (!this.checkingSpinnerWorkItems) {
+            this.checkingSpinnerWorkItems = true;
+            setTimeout(() => {
+                this.checkSpinnerWorkItems();
+            });
+        }
+    }
+    checkSpinnerWorkItems() {
+        this.checkingSpinnerWorkItems = false;
+        if (this.spinnerWorkItemCount) {
+            if (!this._spinnerDialogIsOpen) {
+                this.startDefaultSpinnerDialog();
+            }
+        }
+        else if (this._spinnerDialogIsOpen) {
+            this.stopAllSpinnerDialogs();
+        }
+    }
+    genericDialogContainer(dialogContent, title, icon, config, actionConfig) {
+        let configuration = null;
+        if (!config) {
+            configuration = new MatDialogConfig();
+        }
+        else {
+            configuration = config;
+        }
+        configuration.data = configuration.data ? configuration.data : {};
+        configuration.data.dialogContent = dialogContent;
+        configuration.data.title = title;
+        if (icon) {
+            configuration.data.icon = icon;
+        }
+        if (actionConfig) {
+            configuration.data.actionConfig = actionConfig;
+        }
+        configuration.panelClass = ['mx-sized-dialog', 'no-padding'];
+        configuration.disableClose = true;
+        configuration.hasBackdrop = true;
+        const dialogRef = this.dialog.open(GenericContainerDialogComponent, configuration);
+        return dialogRef.afterClosed();
+    }
+    openDialog(message, title, type, icon, config) {
+        let configuration = null;
+        if (!config) {
+            configuration = new MatDialogConfig();
+        }
+        else {
+            configuration = config;
+        }
+        configuration.data = configuration.data ? configuration.data : {};
+        configuration.data.message = message;
+        configuration.data.title = title ? title : '';
+        configuration.data.icon = icon ? icon : '';
+        configuration.data.dialogType = type ? type : '';
+        configuration.maxWidth = configuration.maxWidth ? configuration.maxWidth : '80vw';
+        configuration.maxHeight = configuration.maxHeight ? configuration.maxHeight : '80vh';
+        configuration.minWidth = configuration.minWidth ? configuration.minWidth : '30em';
+        configuration.panelClass = 'no-padding';
+        configuration.disableClose = true;
+        configuration.autoFocus = false;
+        configuration.hasBackdrop = false;
+        let dialogRef;
+        dialogRef = this.dialog.open(AlertDialogComponent, configuration);
+        return dialogRef.afterClosed();
+    }
+}
+DialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DialogService, deps: [{ token: i1.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+DialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DialogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"ng://@huntsman-cancer-institute/dialog/","sources":["service/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, TemplateRef} from '@angular/core';\r\nimport { MatDialogRef, MatDialog, MatDialogConfig } from '@angular/material/dialog';\r\n\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { AlertDialogComponent } from '../alert/alert-dialog.component';\r\nimport { SpinnerDialogComponent } from '../spinner/spinner-dialog.component';\r\nimport {CustomDialogComponent} from '../custom/custom-dialog.component';\r\nimport {GenericContainerDialogComponent} from '../generic/generic-container-dialog.component';\r\nimport {ActionType, GDActionConfig} from '../model/generic-dialog-action.model';\r\nimport {DialogType} from '../model/dialog-type.model';\r\nimport {ConfirmType} from '../model/confirm-type.model';\r\nimport {ConfirmDialogComponent} from '../confirm/confirm-dialog.component';\r\n\r\n\r\n\r\n@Injectable()\r\nexport class DialogService {\r\n\r\n    private _spinnerDialogIsOpen = false;\r\n    private spinnerWorkItemCount = 0;\r\n    private checkingSpinnerWorkItems = false;\r\n\r\n    public spinnerDialogRefs: MatDialogRef<SpinnerDialogComponent>[] = [];\r\n\r\n    public get spinnerDialogIsOpen(): boolean {\r\n        return this._spinnerDialogIsOpen;\r\n    }\r\n\r\n    constructor(private dialog: MatDialog) {\r\n    }\r\n\r\n    public alert(message: string | string[], title?: string,\r\n                 dialogType?: DialogType, icon?: string,\r\n                 config?: MatDialogConfig): Observable<boolean> {\r\n        return this.openDialog(message, title, dialogType ? dialogType : DialogType.ALERT, icon, config);\r\n    }\r\n\r\n    public confirm(message: string | string[], title?: string,\r\n                   icon?: string, config?: MatDialogConfig): Observable<boolean> {\r\n        return this.openDialog(message, title, DialogType.CONFIRM, icon, config);\r\n\r\n    }\r\n\r\n  /**\r\n   * Creates a ConfirmDialogComponent with different display depending on\r\n   * the ConfirmType.\r\n   * @param title defaults to 'Confirm'\r\n   * @param icon defaults to 'fa fa-info-circle'\r\n   * @param config config.data can contain a prompt, message1 and/or\r\n   * message2 according to the ConfirmType chosen\r\n   * @param actionConfig sets up the dialog buttons and actions if you want\r\n   * to override the defaults\r\n   */\r\n  public confirmByType(confirmType: ConfirmType, title?: string,\r\n                       icon?: string, config?: MatDialogConfig,\r\n                       actionConfig?: GDActionConfig): Observable<boolean> {\r\n    if (!title){\r\n      title = 'Confirm';\r\n    }\r\n\r\n    if (!icon){\r\n      icon = 'fa fa-info-circle';\r\n    }\r\n\r\n    // set up a default if needed\r\n    if (!config){\r\n      config = new MatDialogConfig<any>();\r\n      config.width = '33vw';\r\n      config.minWidth = '300px';\r\n      config.disableClose = true;\r\n    }\r\n\r\n    if (config.data){\r\n      config.data.confirmType = confirmType;\r\n    }else {\r\n      config.data = {\r\n        confirmType\r\n      };\r\n    }\r\n\r\n    // if no actions passed in, set up the defaults\r\n    if (!actionConfig){\r\n\r\n      // default actions\r\n      let primary = {type: ActionType.PRIMARY, name: 'YES',\r\n        internalAction: 'onConfirmClick', internalActionReturnValue: true};\r\n      let secondary = {type: ActionType.SECONDARY, name: 'GO BACK',\r\n        internalAction: 'onClose'};\r\n\r\n      // by enum type, setup the messages/prompt\r\n      // only two need different defaults than generic defaults\r\n      switch (confirmType) {\r\n        case ConfirmType.CONFIRM_AND_CLOSE:\r\n          primary = {type: ActionType.PRIMARY, name: 'CONFIRM AND CLOSE',\r\n            internalAction: 'onConfirmClick', internalActionReturnValue: true};\r\n          break;\r\n        case ConfirmType.ALERT:\r\n          primary = undefined;\r\n          secondary = {type: ActionType.SECONDARY, name: 'CLOSE',\r\n            internalAction: 'onClose'};\r\n          break;\r\n        // case ConfirmType.DELETE:\r\n        // case ConfirmType.DELETE_W_MESSAGE:\r\n        // case ConfirmType.DELETE_W_PROMPT:\r\n        // case ConfirmType.DISCARD:\r\n        // case ConfirmType.ADD:\r\n        // case ConfirmType.GENERIC:\r\n        default:\r\n          throw new Error('Confirm type doesn\\'t exist');\r\n      }\r\n\r\n      const actions = [];\r\n      if (primary){\r\n        actions.push(primary);\r\n      }\r\n      if (secondary){\r\n        actions.push(secondary);\r\n      }\r\n\r\n      actionConfig = {\r\n        actions\r\n      };\r\n    }\r\n\r\n    return this.genericDialogContainer(ConfirmDialogComponent,\r\n      title, icon, config, actionConfig);\r\n  }\r\n\r\n    public error(message: string | string[], title?: string,\r\n                 icon?: string, config?: MatDialogConfig): Observable<boolean> {\r\n        return this.openDialog(message, title, DialogType.ERROR, icon, config);\r\n    }\r\n\r\n    public info(message: string | string[], title?: string,\r\n                icon?: string, config?: MatDialogConfig): Observable<boolean> {\r\n        return this.openDialog(message, title, DialogType.INFO, icon, config);\r\n    }\r\n\r\n    public createCustomDialog(tempRef: TemplateRef<any>, context?: any, title?: string,\r\n                              icon?: string, config?: MatDialogConfig,\r\n                              actionConfig?: GDActionConfig) {\r\n        let configuration: MatDialogConfig = null;\r\n        if (!config) {\r\n            configuration = new MatDialogConfig();\r\n        } else {\r\n            configuration = config;\r\n        }\r\n\r\n        configuration.data = configuration.data ? configuration.data : {};\r\n        configuration.data.templateRef = tempRef;\r\n        configuration.data.title = title ? title : '';\r\n        configuration.data.icon = icon ? icon : '';\r\n        configuration.data.context = context;\r\n        if (actionConfig) {\r\n            configuration.data.actionConfig = actionConfig;\r\n        }\r\n\r\n        configuration.minWidth = configuration.minWidth ? configuration.minWidth : '10em';\r\n        configuration.width = configuration.width ? configuration.width : '30em';\r\n\r\n        configuration.panelClass = ['mx-sized-dialog', 'no-padding'];\r\n        configuration.disableClose = true;\r\n        configuration.hasBackdrop = true;\r\n\r\n        const dialogRef = this.dialog.open(CustomDialogComponent, configuration);\r\n\r\n        return dialogRef;\r\n    }\r\n\r\n    public startDefaultSpinnerDialog(): MatDialogRef<SpinnerDialogComponent> {\r\n        return this.startSpinnerDialog('Please wait...', 3, 30);\r\n    }\r\n\r\n    public startSpinnerDialog(message: string, strokeWidth: number, diameter: number): MatDialogRef<SpinnerDialogComponent> {\r\n        if (this._spinnerDialogIsOpen) {\r\n            return null;\r\n        }\r\n\r\n        this._spinnerDialogIsOpen = true;\r\n\r\n        const configuration: MatDialogConfig = new MatDialogConfig();\r\n        configuration.data = {\r\n            message,\r\n            strokeWidth,\r\n            diameter\r\n        };\r\n        configuration.width = '13em';\r\n        configuration.disableClose = true;\r\n\r\n        const dialogRef: MatDialogRef<SpinnerDialogComponent> = this.dialog.open(SpinnerDialogComponent, configuration);\r\n\r\n        dialogRef.afterClosed().subscribe(() => {\r\n            this._spinnerDialogIsOpen = false;\r\n        });\r\n\r\n        this.spinnerDialogRefs.push(dialogRef);\r\n\r\n        return dialogRef;\r\n    }\r\n\r\n    public startNonModalSpinnerDialog(message: string, strokeWidth: number, diameter: number): MatDialogRef<SpinnerDialogComponent> {\r\n        if (this._spinnerDialogIsOpen) {\r\n            return null;\r\n        }\r\n\r\n        this._spinnerDialogIsOpen = true;\r\n\r\n        const configuration: MatDialogConfig = new MatDialogConfig();\r\n        configuration.data = {\r\n            message,\r\n            strokeWidth,\r\n            diameter\r\n        };\r\n        configuration.width = '13em';\r\n        configuration.disableClose = true;\r\n        configuration.hasBackdrop = false;\r\n\r\n        const dialogRef: MatDialogRef<SpinnerDialogComponent> = this.dialog.open(SpinnerDialogComponent, configuration);\r\n\r\n        dialogRef.afterClosed().subscribe(() => {\r\n            this._spinnerDialogIsOpen = false;\r\n        });\r\n\r\n        this.spinnerDialogRefs.push(dialogRef);\r\n\r\n        return dialogRef;\r\n    }\r\n\r\n    // Let there be an alternative, global way to stop all active spinner dialogs.\r\n    public stopAllSpinnerDialogs(): void {\r\n        this.spinnerWorkItemCount = 0;\r\n        for (const dialogRef of this.spinnerDialogRefs) {\r\n            setTimeout(() => {\r\n                dialogRef.close();\r\n            });\r\n        }\r\n        this.spinnerDialogRefs = [];\r\n    }\r\n\r\n    public addSpinnerWorkItem(): void {\r\n        this.spinnerWorkItemCount++;\r\n        if (!this.checkingSpinnerWorkItems) {\r\n            this.checkingSpinnerWorkItems = true;\r\n            setTimeout(() => {\r\n                this.checkSpinnerWorkItems();\r\n            });\r\n        }\r\n    }\r\n\r\n    public removeSpinnerWorkItem(): void {\r\n        this.spinnerWorkItemCount--;\r\n        if (this.spinnerWorkItemCount < 0) {\r\n            this.spinnerWorkItemCount = 0;\r\n        }\r\n        if (!this.checkingSpinnerWorkItems) {\r\n            this.checkingSpinnerWorkItems = true;\r\n            setTimeout(() => {\r\n                this.checkSpinnerWorkItems();\r\n            });\r\n        }\r\n    }\r\n\r\n    private checkSpinnerWorkItems(): void {\r\n        this.checkingSpinnerWorkItems = false;\r\n        if (this.spinnerWorkItemCount) {\r\n            if (!this._spinnerDialogIsOpen) {\r\n                this.startDefaultSpinnerDialog();\r\n            }\r\n        } else if (this._spinnerDialogIsOpen) {\r\n            this.stopAllSpinnerDialogs();\r\n        }\r\n    }\r\n\r\n    public genericDialogContainer(dialogContent: any, title: string,\r\n                                  icon?: string, config?: MatDialogConfig,\r\n                                  actionConfig?: GDActionConfig): Observable<any> {\r\n        let configuration: MatDialogConfig = null;\r\n\r\n\r\n        if (!config) {\r\n            configuration = new MatDialogConfig();\r\n        } else {\r\n            configuration = config;\r\n        }\r\n        configuration.data = configuration.data ? configuration.data : {};\r\n        configuration.data.dialogContent = dialogContent;\r\n        configuration.data.title = title;\r\n        if (icon) {\r\n            configuration.data.icon = icon;\r\n        }\r\n        if (actionConfig) {\r\n            configuration.data.actionConfig = actionConfig;\r\n        }\r\n        configuration.panelClass = ['mx-sized-dialog', 'no-padding'];\r\n        configuration.disableClose = true;\r\n        configuration.hasBackdrop = true;\r\n        const dialogRef = this.dialog.open(GenericContainerDialogComponent, configuration);\r\n\r\n        return dialogRef.afterClosed();\r\n    }\r\n\r\n    private openDialog(message: string | string[], title?: string,\r\n                       type?: DialogType, icon?: string, config?: MatDialogConfig): Observable<any> {\r\n        let configuration: MatDialogConfig = null;\r\n        if (!config) {\r\n            configuration = new MatDialogConfig();\r\n        } else {\r\n            configuration = config;\r\n        }\r\n\r\n        configuration.data = configuration.data ? configuration.data : {};\r\n        configuration.data.message = message;\r\n        configuration.data.title = title ? title : '';\r\n        configuration.data.icon = icon ? icon : '';\r\n        configuration.data.dialogType = type ? type : '';\r\n\r\n        configuration.maxWidth = configuration.maxWidth ? configuration.maxWidth : '80vw';\r\n        configuration.maxHeight = configuration.maxHeight ? configuration.maxHeight : '80vh';\r\n        configuration.minWidth = configuration.minWidth ? configuration.minWidth : '30em';\r\n\r\n        configuration.panelClass = 'no-padding';\r\n        configuration.disableClose = true;\r\n        configuration.autoFocus = false;\r\n        configuration.hasBackdrop = false;\r\n\r\n        let dialogRef: MatDialogRef<AlertDialogComponent>;\r\n\r\n        dialogRef = this.dialog.open(AlertDialogComponent, configuration);\r\n\r\n        return dialogRef.afterClosed();\r\n    }\r\n\r\n\r\n}\r\n"]}

package/esm2015/spinner/spinner-dialog.component.js

@@ -0,0 +1,69 @@
+import { Component, Inject, Input } from '@angular/core';
+import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/material/progress-spinner";
+export class SpinnerDialogComponent {
+    constructor(dialogRef, data) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.strokeWidth = 3;
+        this.diameter = 30;
+        this.message = 'Loading...';
+        if (this.data) {
+            if (!!this.data.message) {
+                this.message = this.data.message;
+            }
+            if (!!this.data.diameter) {
+                this.diameter = this.data.diameter;
+            }
+            if (!!this.data.strokeWidth) {
+                this.strokeWidth = this.data.strokeWidth;
+            }
+        }
+    }
+}
+SpinnerDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SpinnerDialogComponent, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component });
+SpinnerDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: SpinnerDialogComponent, selector: "hci-spinner-dialog", inputs: { strokeWidth: "strokeWidth", diameter: "diameter", message: "message" }, ngImport: i0, template: "<div mat-dialog-title class=\"not-rendered\">\r\n<!--<div mat-dialog-title>-->\r\n</div>\r\n<div mat-dialog-content class=\"full-height padded\">\r\n    <div class=\"full-width full-height t\">\r\n        <div class=\"tr\">\r\n            <div class=\"td vertical-center\" [style.height.px]=\"diameter + 5\">\r\n                <mat-spinner [hidden]=\"false\" strokeWidth=\"{{strokeWidth}}\" [diameter]=\"diameter\"></mat-spinner>\r\n            </div>\r\n            <div class=\"td vertical-center\">\r\n                {{message}}\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>\r\n<div mat-dialog-actions class=\"not-rendered\">\r\n<!--<div mat-dialog-actions>-->\r\n</div>\r\n", styles: ["\n        .t  { display: table; }\n        .tr { display: table-row; }\n        .td { display: table-cell; }\n\n        .full-height { height: 100%; }\n        .full-width  { width:  100%; }\n\n        .vertical-center { vertical-align: middle; }\n\n        .padded {\n            padding-top: 0.4em;\n            padding-bottom: 0.4em;\n        }\n\n        .not-rendered {\n            padding: 0;\n            margin:  0;\n\n            min-height: 0;\n            max-height: 0;\n            height:     0;\n        }\n\n    "], components: [{ type: i2.MatSpinner, selector: "mat-spinner", inputs: ["color"] }], directives: [{ type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SpinnerDialogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'hci-spinner-dialog',
+                    templateUrl: 'spinner-dialog.component.html',
+                    styles: [`
+        .t  { display: table; }
+        .tr { display: table-row; }
+        .td { display: table-cell; }
+
+        .full-height { height: 100%; }
+        .full-width  { width:  100%; }
+
+        .vertical-center { vertical-align: middle; }
+
+        .padded {
+            padding-top: 0.4em;
+            padding-bottom: 0.4em;
+        }
+
+        .not-rendered {
+            padding: 0;
+            margin:  0;
+
+            min-height: 0;
+            max-height: 0;
+            height:     0;
+        }
+
+    `]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }]; }, propDecorators: { strokeWidth: [{
+                type: Input
+            }], diameter: [{
+                type: Input
+            }], message: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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