@huntsman-cancer-institute/dialog 12.11.9-SNAPSHOT

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

@@ -0,0 +1,231 @@
+import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
+import { ChangeDetectorRef, Component, ElementRef, HostListener, Inject, ViewChild, ViewContainerRef, } from '@angular/core';
+import { ActionType } from '../model/generic-dialog-action.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/common";
+export class CustomDialogComponent {
+    constructor(dialogRef, data, changeDetector) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.changeDetector = changeDetector;
+        this.title = '';
+        this.icon = '';
+        this.actionType = ActionType;
+        this.originalXClick = 0;
+        this.originalYClick = 0;
+        this.movingDialog = false;
+        this.positionX = 0;
+        this.positionY = 0;
+        this.actions = [];
+        this.title = data.title;
+        this.tempRef = data.templateRef;
+        this.icon = data.icon;
+        this.context = data.context;
+        const actionConfig = data.actionConfig ? data.actionConfig : null;
+        this.actions = actionConfig ? actionConfig.actions : [];
+        this.form = actionConfig && actionConfig.formSource ? actionConfig.formSource : null;
+    }
+    get primaryDisable() {
+        return this.form && this.form.invalid;
+    }
+    // todo need make this customizable
+    get secondaryDisable() {
+        return false;
+    }
+    ngOnInit() {
+        this.context.dialog = this.dialogRef;
+        this.vcr.createEmbeddedView(this.tempRef, this.context);
+    }
+    onClose() {
+        this.dialogRef.close();
+    }
+    onMouseDownHeader(event) {
+        if (!event) {
+            return;
+        }
+        this.positionX = this.topmostLeftmost.nativeElement.offsetLeft;
+        this.positionY = this.topmostLeftmost.nativeElement.offsetTop;
+        this.originalXClick = event.screenX;
+        this.originalYClick = event.screenY;
+        this.movingDialog = true;
+        this.changeDetector.detach();
+    }
+    onMouseMove(event) {
+        if (!event) {
+            return;
+        }
+        if (this.movingDialog) {
+            this.positionX += event.screenX - this.originalXClick;
+            this.positionY += event.screenY - this.originalYClick;
+            this.originalXClick = event.screenX;
+            this.originalYClick = event.screenY;
+            const newDialogPosition = {
+                left: '' + this.positionX + 'px',
+                top: '' + this.positionY + 'px',
+            };
+            this.dialogRef.updatePosition(newDialogPosition);
+        }
+    }
+    onMouseUp() {
+        this.movingDialog = false;
+        this.changeDetector.reattach();
+    }
+    executeAction(action) {
+        if (action.externalAction) {
+            action.externalAction(this.dialogRef);
+        }
+        if (action.internalAction && action.internalAction === 'onClose') {
+            this.onClose();
+        }
+    }
+}
+CustomDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CustomDialogComponent, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+CustomDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: CustomDialogComponent, selector: "hci-custom-dialog", host: { listeners: { "window:mousemove": "onMouseMove($event)", "window:mouseup": "onMouseUp($event)" } }, viewQueries: [{ propertyName: "vcr", first: true, predicate: ["anchor"], descendants: true, read: ViewContainerRef, static: true }, { propertyName: "topmostLeftmost", first: true, predicate: ["topmostLeftmost"], descendants: true }], ngImport: i0, template: `
+        <div class="d-flex full-height full-width flex-column">
+            <div *ngIf="this.title" class="full-width generic-dialog-header-colors no-margin no-padding">
+                <div #topmostLeftmost mat-dialog-title (mousedown)="onMouseDownHeader($event)"
+                     class="force-flex-container-row align-items-center full-width p-2   {{ movingDialog ? 'grabbed' : 'grabbable' }}">
+                    <div class="-flex flex-row align-items-center padded">
+                        <img  *ngIf="icon" class="icon" [src]="this.icon">
+                        <div *ngIf="icon && icon.substr(0, 2) === '<i'" class="i-class" [innerHTML]="icon" ></div>
+                        <h3 style="margin:0;">{{this.title}}</h3>
+                    </div>
+                    <div class="flex-grow-1"></div>
+                    <div class="padded" (click)="onClose()">
+                        <i class="exit fas fa-times"></i>
+                    </div>
+                </div>
+            </div>
+            <mat-dialog-content class="flex-grow-1 full-width no-margin p-2" style="min-height: 6em;">
+                <div #anchor></div>
+            </mat-dialog-content>
+            <mat-dialog-actions *ngIf="actions && actions.length > 0"
+                                class="d-flex flex-row justify-content-end no-margin no-padding generic-dialog-footer-colors">
+                <div *ngFor="let action of actions">
+                    <save-footer *ngIf="action.type === actionType.PRIMARY;else secondary"
+                                 [actionType]="action.type"
+                                 [icon]="action.icon"
+                                 [disableSave]="primaryDisable"
+                                 (saveClicked)="executeAction(action)"
+                                 [name]="action.name">
+                    </save-footer>
+                    <!-- to avoid issue with multiple spinner or dirty notes-->
+                    <ng-template #secondary>
+                        <save-footer [actionType]="action.type"
+                                     (saveClicked)="executeAction(action)"
+                                     [icon]="action.icon"
+                                     [disableSave]="secondaryDisable"
+                                     [name]="action.name">
+                        </save-footer>
+                    </ng-template>
+                </div>
+            </mat-dialog-actions>
+        </div>
+    `, isInline: true, styles: ["\n        .centered-text { text-align: center; }\n\n        .no-padding{\n            padding:0;\n\n        }\n\n        .no-margin{\n            margin: 0;\n        }\n\n        .grabbable {\n            cursor: move;\n            cursor: grab;\n            cursor: -moz-grab;\n            cursor: -webkit-grab;\n        }\n        .grabbed:active {\n            cursor: grabbing;\n            cursor: -moz-grabbing;\n            cursor: -webkit-grabbing;\n        }\n\n        .force-flex-container-row{\n            display:flex !important;\n        }\n\n        .exit{\n            max-width: 20px;\n            cursor: pointer;\n        }\n\n        .i-class {\n            margin-left:  0.3em;\n            margin-right: 0.3em;\n        }\n        mat-dialog-content {\n            max-height: 100vh !important;\n            max-width: 100vw !important ;\n        }\n    "], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { 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]" }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CustomDialogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'hci-custom-dialog',
+                    template: `
+        <div class="d-flex full-height full-width flex-column">
+            <div *ngIf="this.title" class="full-width generic-dialog-header-colors no-margin no-padding">
+                <div #topmostLeftmost mat-dialog-title (mousedown)="onMouseDownHeader($event)"
+                     class="force-flex-container-row align-items-center full-width p-2   {{ movingDialog ? 'grabbed' : 'grabbable' }}">
+                    <div class="-flex flex-row align-items-center padded">
+                        <img  *ngIf="icon" class="icon" [src]="this.icon">
+                        <div *ngIf="icon && icon.substr(0, 2) === '<i'" class="i-class" [innerHTML]="icon" ></div>
+                        <h3 style="margin:0;">{{this.title}}</h3>
+                    </div>
+                    <div class="flex-grow-1"></div>
+                    <div class="padded" (click)="onClose()">
+                        <i class="exit fas fa-times"></i>
+                    </div>
+                </div>
+            </div>
+            <mat-dialog-content class="flex-grow-1 full-width no-margin p-2" style="min-height: 6em;">
+                <div #anchor></div>
+            </mat-dialog-content>
+            <mat-dialog-actions *ngIf="actions && actions.length > 0"
+                                class="d-flex flex-row justify-content-end no-margin no-padding generic-dialog-footer-colors">
+                <div *ngFor="let action of actions">
+                    <save-footer *ngIf="action.type === actionType.PRIMARY;else secondary"
+                                 [actionType]="action.type"
+                                 [icon]="action.icon"
+                                 [disableSave]="primaryDisable"
+                                 (saveClicked)="executeAction(action)"
+                                 [name]="action.name">
+                    </save-footer>
+                    <!-- to avoid issue with multiple spinner or dirty notes-->
+                    <ng-template #secondary>
+                        <save-footer [actionType]="action.type"
+                                     (saveClicked)="executeAction(action)"
+                                     [icon]="action.icon"
+                                     [disableSave]="secondaryDisable"
+                                     [name]="action.name">
+                        </save-footer>
+                    </ng-template>
+                </div>
+            </mat-dialog-actions>
+        </div>
+    `,
+                    styles: [`
+        .centered-text { text-align: center; }
+
+        .no-padding{
+            padding:0;
+
+        }
+
+        .no-margin{
+            margin: 0;
+        }
+
+        .grabbable {
+            cursor: move;
+            cursor: grab;
+            cursor: -moz-grab;
+            cursor: -webkit-grab;
+        }
+        .grabbed:active {
+            cursor: grabbing;
+            cursor: -moz-grabbing;
+            cursor: -webkit-grabbing;
+        }
+
+        .force-flex-container-row{
+            display:flex !important;
+        }
+
+        .exit{
+            max-width: 20px;
+            cursor: pointer;
+        }
+
+        .i-class {
+            margin-left:  0.3em;
+            margin-right: 0.3em;
+        }
+        mat-dialog-content {
+            max-height: 100vh !important;
+            max-width: 100vw !important ;
+        }
+    `]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { vcr: [{
+                type: ViewChild,
+                args: ['anchor', { read: ViewContainerRef, static: true }]
+            }], topmostLeftmost: [{
+                type: ViewChild,
+                args: ['topmostLeftmost', { static: false }]
+            }], onMouseMove: [{
+                type: HostListener,
+                args: ['window:mousemove', ['$event']]
+            }], onMouseUp: [{
+                type: HostListener,
+                args: ['window:mouseup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-dialog.component.js","sourceRoot":"ng://@huntsman-cancer-institute/dialog/","sources":["custom/custom-dialog.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {DialogPosition, MAT_DIALOG_DATA, MatDialogRef} from '@angular/material/dialog';\r\nimport {\r\n    ChangeDetectorRef,\r\n    Component, ElementRef,\r\n    HostListener,\r\n    Inject, OnInit,\r\n    TemplateRef,\r\n    ViewChild,\r\n    ViewContainerRef,\r\n} from '@angular/core';\r\nimport {ActionType, GDAction, GDActionConfig} from '../model/generic-dialog-action.model';\r\nimport {FormGroup} from '@angular/forms';\r\n\r\n@Component({\r\n    selector: 'hci-custom-dialog',\r\n    template: `\r\n        <div class=\"d-flex full-height full-width flex-column\">\r\n            <div *ngIf=\"this.title\" class=\"full-width generic-dialog-header-colors no-margin no-padding\">\r\n                <div #topmostLeftmost mat-dialog-title (mousedown)=\"onMouseDownHeader($event)\"\r\n                     class=\"force-flex-container-row align-items-center full-width p-2   {{ movingDialog ? 'grabbed' : 'grabbable' }}\">\r\n                    <div class=\"-flex flex-row align-items-center padded\">\r\n                        <img  *ngIf=\"icon\" class=\"icon\" [src]=\"this.icon\">\r\n                        <div *ngIf=\"icon && icon.substr(0, 2) === '<i'\" class=\"i-class\" [innerHTML]=\"icon\" ></div>\r\n                        <h3 style=\"margin:0;\">{{this.title}}</h3>\r\n                    </div>\r\n                    <div class=\"flex-grow-1\"></div>\r\n                    <div class=\"padded\" (click)=\"onClose()\">\r\n                        <i class=\"exit fas fa-times\"></i>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n            <mat-dialog-content class=\"flex-grow-1 full-width no-margin p-2\" style=\"min-height: 6em;\">\r\n                <div #anchor></div>\r\n            </mat-dialog-content>\r\n            <mat-dialog-actions *ngIf=\"actions && actions.length > 0\"\r\n                                class=\"d-flex flex-row justify-content-end no-margin no-padding generic-dialog-footer-colors\">\r\n                <div *ngFor=\"let action of actions\">\r\n                    <save-footer *ngIf=\"action.type === actionType.PRIMARY;else secondary\"\r\n                                 [actionType]=\"action.type\"\r\n                                 [icon]=\"action.icon\"\r\n                                 [disableSave]=\"primaryDisable\"\r\n                                 (saveClicked)=\"executeAction(action)\"\r\n                                 [name]=\"action.name\">\r\n                    </save-footer>\r\n                    <!-- to avoid issue with multiple spinner or dirty notes-->\r\n                    <ng-template #secondary>\r\n                        <save-footer [actionType]=\"action.type\"\r\n                                     (saveClicked)=\"executeAction(action)\"\r\n                                     [icon]=\"action.icon\"\r\n                                     [disableSave]=\"secondaryDisable\"\r\n                                     [name]=\"action.name\">\r\n                        </save-footer>\r\n                    </ng-template>\r\n                </div>\r\n            </mat-dialog-actions>\r\n        </div>\r\n    `,\r\n    styles: [`\r\n        .centered-text { text-align: center; }\r\n\r\n        .no-padding{\r\n            padding:0;\r\n\r\n        }\r\n\r\n        .no-margin{\r\n            margin: 0;\r\n        }\r\n\r\n        .grabbable {\r\n            cursor: move;\r\n            cursor: grab;\r\n            cursor: -moz-grab;\r\n            cursor: -webkit-grab;\r\n        }\r\n        .grabbed:active {\r\n            cursor: grabbing;\r\n            cursor: -moz-grabbing;\r\n            cursor: -webkit-grabbing;\r\n        }\r\n\r\n        .force-flex-container-row{\r\n            display:flex !important;\r\n        }\r\n\r\n        .exit{\r\n            max-width: 20px;\r\n            cursor: pointer;\r\n        }\r\n\r\n        .i-class {\r\n            margin-left:  0.3em;\r\n            margin-right: 0.3em;\r\n        }\r\n        mat-dialog-content {\r\n            max-height: 100vh !important;\r\n            max-width: 100vw !important ;\r\n        }\r\n    `]\r\n})\r\n\r\nexport class CustomDialogComponent implements OnInit {\r\n    @ViewChild('anchor', { read: ViewContainerRef, static : true }) vcr: ViewContainerRef;\r\n    @ViewChild('topmostLeftmost', {static: false}) topmostLeftmost: ElementRef;\r\n    public title = '';\r\n    public icon = '';\r\n\r\n    public actionType: any = ActionType;\r\n\r\n    originalXClick = 0;\r\n    originalYClick = 0;\r\n    movingDialog = false;\r\n    protected positionX = 0;\r\n    protected positionY = 0;\r\n    context: any;\r\n\r\n    private tempRef: TemplateRef<any>;\r\n    public actions: GDAction[] = [];\r\n    public form: FormGroup;\r\n    public get primaryDisable(): boolean {\r\n        return this.form && this.form.invalid;\r\n    }\r\n    // todo need make this customizable\r\n    public get secondaryDisable(): boolean {\r\n        return false;\r\n    }\r\n\r\n    constructor(public dialogRef: MatDialogRef<CustomDialogComponent>,\r\n                @Inject(MAT_DIALOG_DATA) private data: any,\r\n                private changeDetector: ChangeDetectorRef) {\r\n        this.title = data.title;\r\n        this.tempRef = data.templateRef;\r\n        this.icon = data.icon;\r\n        this.context = data.context;\r\n        const actionConfig: GDActionConfig = data.actionConfig ? data.actionConfig as GDActionConfig : null;\r\n        this.actions = actionConfig ? actionConfig.actions : [];\r\n        this.form = actionConfig && actionConfig.formSource ?  actionConfig.formSource : null;\r\n\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.context.dialog = this.dialogRef;\r\n        this.vcr.createEmbeddedView<any>(this.tempRef, this.context);\r\n\r\n    }\r\n\r\n    onClose() {\r\n        this.dialogRef.close();\r\n    }\r\n\r\n    onMouseDownHeader(event: any): void {\r\n        if (!event) {\r\n            return;\r\n        }\r\n\r\n        this.positionX = this.topmostLeftmost.nativeElement.offsetLeft;\r\n        this.positionY = this.topmostLeftmost.nativeElement.offsetTop;\r\n\r\n        this.originalXClick = event.screenX;\r\n        this.originalYClick = event.screenY;\r\n\r\n        this.movingDialog = true;\r\n        this.changeDetector.detach();\r\n    }\r\n    @HostListener('window:mousemove', ['$event'])\r\n    onMouseMove(event: any): void {\r\n        if (!event) {\r\n            return;\r\n        }\r\n\r\n        if (this.movingDialog) {\r\n            this.positionX += event.screenX - this.originalXClick;\r\n            this.positionY += event.screenY - this.originalYClick;\r\n\r\n            this.originalXClick = event.screenX;\r\n            this.originalYClick = event.screenY;\r\n\r\n            const newDialogPosition: DialogPosition = {\r\n                left:   '' + this.positionX + 'px',\r\n                top:    '' + this.positionY + 'px',\r\n            };\r\n\r\n            this.dialogRef.updatePosition(newDialogPosition);\r\n        }\r\n    }\r\n    @HostListener('window:mouseup', ['$event'])\r\n    onMouseUp(): void {\r\n        this.movingDialog = false;\r\n        this.changeDetector.reattach();\r\n    }\r\n\r\n    executeAction(action: GDAction): void {\r\n        if (action.externalAction) {\r\n            action.externalAction(this.dialogRef);\r\n        }\r\n        if (action.internalAction && action.internalAction === 'onClose') {\r\n            this.onClose();\r\n        }\r\n    }\r\n\r\n}\r\n"]}

package/esm2015/dialog.module.js

@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { DialogService } from './service/dialog.service';
+import { AlertDialogComponent } from './alert/alert-dialog.component';
+import { CustomDialogComponent } from './custom/custom-dialog.component';
+import { GenericContainerDialogComponent } from './generic/generic-container-dialog.component';
+import { SaveFooterComponent } from './save-footer/save-footer.component';
+import { SpinnerDialogComponent } from './spinner/spinner-dialog.component';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { DynamicModule } from 'ng-dynamic-component';
+import { ConfirmDialogComponent } from './confirm/confirm-dialog.component';
+import { MatExpansionModule } from '@angular/material/expansion';
+import * as i0 from "@angular/core";
+// import {RouterModule} from "@angular/router";
+// import {MatButtonToggleModule} from "@angular/material/button-toggle";
+// import {MatInputModule} from "@angular/material/input";
+// import {MatIconModule} from "@angular/material/icon";
+// import {TreeModule} from "@circlon/angular-tree-component";
+// import {MatDatepickerModule} from "@angular/material/datepicker";
+// import {MatSelectModule} from "@angular/material/select";
+// import {NgbModule, NgbNavModule} from "@ng-bootstrap/ng-bootstrap";
+// import {MiscModule} from "@huntsman-cancer-institute/misc";
+// import { MatNativeDateModule } from "@angular/material/core";
+// import { MatCheckboxModule } from '@angular/material/checkbox';
+/**
+ * The main @huntsman-cancer-institute/dialog module.  The module exports all components that an implementation might use
+ * and the forRoot() provides a global service for an implementing application.
+ *
+ * @since 1.0.0
+ */
+export class DialogModule {
+    static forRoot() {
+        return {
+            providers: [
+                DialogService
+            ],
+            ngModule: DialogModule
+        };
+    }
+}
+DialogModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DialogModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DialogModule, declarations: [AlertDialogComponent,
+        ConfirmDialogComponent,
+        CustomDialogComponent,
+        GenericContainerDialogComponent,
+        SaveFooterComponent,
+        SpinnerDialogComponent], imports: [CommonModule,
+        FormsModule,
+        DynamicModule,
+        MatButtonModule,
+        MatDialogModule,
+        MatExpansionModule,
+        MatProgressSpinnerModule
+        // RouterModule,
+        // MiscModule,
+        // NgbModule,
+        // MatButtonToggleModule,
+        // MatInputModule,
+        // MatIconModule,
+        // MatDatepickerModule,
+        // MatNativeDateModule,
+        // MatCheckboxModule,
+        // MatRadioModule,
+        // MatSelectModule,
+        // TreeModule,
+        // NgbNavModule
+    ], exports: [AlertDialogComponent,
+        ConfirmDialogComponent,
+        CustomDialogComponent,
+        GenericContainerDialogComponent,
+        SaveFooterComponent,
+        SpinnerDialogComponent] });
+DialogModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DialogModule, providers: [
+    // MatDatepickerModule,
+    ], imports: [[
+            CommonModule,
+            FormsModule,
+            DynamicModule,
+            MatButtonModule,
+            MatDialogModule,
+            MatExpansionModule,
+            MatProgressSpinnerModule
+            // RouterModule,
+            // MiscModule,
+            // NgbModule,
+            // MatButtonToggleModule,
+            // MatInputModule,
+            // MatIconModule,
+            // MatDatepickerModule,
+            // MatNativeDateModule,
+            // MatCheckboxModule,
+            // MatRadioModule,
+            // MatSelectModule,
+            // TreeModule,
+            // NgbNavModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DialogModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        DynamicModule,
+                        MatButtonModule,
+                        MatDialogModule,
+                        MatExpansionModule,
+                        MatProgressSpinnerModule
+                        // RouterModule,
+                        // MiscModule,
+                        // NgbModule,
+                        // MatButtonToggleModule,
+                        // MatInputModule,
+                        // MatIconModule,
+                        // MatDatepickerModule,
+                        // MatNativeDateModule,
+                        // MatCheckboxModule,
+                        // MatRadioModule,
+                        // MatSelectModule,
+                        // TreeModule,
+                        // NgbNavModule
+                    ],
+                    providers: [
+                    // MatDatepickerModule,
+                    ],
+                    declarations: [
+                        AlertDialogComponent,
+                        ConfirmDialogComponent,
+                        CustomDialogComponent,
+                        GenericContainerDialogComponent,
+                        SaveFooterComponent,
+                        SpinnerDialogComponent
+                    ],
+                    entryComponents: [
+                        AlertDialogComponent,
+                        ConfirmDialogComponent,
+                        CustomDialogComponent,
+                        GenericContainerDialogComponent,
+                        SaveFooterComponent,
+                        SpinnerDialogComponent
+                    ],
+                    exports: [
+                        AlertDialogComponent,
+                        ConfirmDialogComponent,
+                        CustomDialogComponent,
+                        GenericContainerDialogComponent,
+                        SaveFooterComponent,
+                        SpinnerDialogComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.module.js","sourceRoot":"ng://@huntsman-cancer-institute/dialog/","sources":["dialog.module.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary\r\n */\r\nimport {ModuleWithProviders, NgModule} from '@angular/core';\r\nimport {CommonModule} from '@angular/common';\r\nimport {FormsModule} from '@angular/forms';\r\nimport {DialogService} from './service/dialog.service';\r\nimport {AlertDialogComponent} from './alert/alert-dialog.component';\r\nimport {CustomDialogComponent} from './custom/custom-dialog.component';\r\nimport {GenericContainerDialogComponent} from './generic/generic-container-dialog.component';\r\nimport {SaveFooterComponent} from './save-footer/save-footer.component';\r\nimport {SpinnerDialogComponent} from './spinner/spinner-dialog.component';\r\nimport {MatButtonModule} from '@angular/material/button';\r\nimport {MatDialogModule} from '@angular/material/dialog';\r\nimport {MatProgressSpinnerModule} from '@angular/material/progress-spinner';\r\nimport {DynamicModule} from 'ng-dynamic-component';\r\nimport {ConfirmDialogComponent} from './confirm/confirm-dialog.component';\r\nimport {MatExpansionModule} from '@angular/material/expansion';\r\n// import {RouterModule} from \"@angular/router\";\r\n// import {MatButtonToggleModule} from \"@angular/material/button-toggle\";\r\n// import {MatInputModule} from \"@angular/material/input\";\r\n// import {MatIconModule} from \"@angular/material/icon\";\r\n// import {TreeModule} from \"@circlon/angular-tree-component\";\r\n// import {MatDatepickerModule} from \"@angular/material/datepicker\";\r\n// import {MatSelectModule} from \"@angular/material/select\";\r\n// import {NgbModule, NgbNavModule} from \"@ng-bootstrap/ng-bootstrap\";\r\n// import {MiscModule} from \"@huntsman-cancer-institute/misc\";\r\n// import { MatNativeDateModule } from \"@angular/material/core\";\r\n// import { MatCheckboxModule } from '@angular/material/checkbox';\r\n\r\n\r\n/**\r\n * The main @huntsman-cancer-institute/dialog module.  The module exports all components that an implementation might use\r\n * and the forRoot() provides a global service for an implementing application.\r\n *\r\n * @since 1.0.0\r\n */\r\n@NgModule({\r\n  imports: [\r\n    CommonModule,\r\n    FormsModule,\r\n    DynamicModule,\r\n    MatButtonModule,\r\n    MatDialogModule,\r\n    MatExpansionModule,\r\n    MatProgressSpinnerModule\r\n    // RouterModule,\r\n    // MiscModule,\r\n    // NgbModule,\r\n    // MatButtonToggleModule,\r\n    // MatInputModule,\r\n    // MatIconModule,\r\n    // MatDatepickerModule,\r\n    // MatNativeDateModule,\r\n    // MatCheckboxModule,\r\n    // MatRadioModule,\r\n    // MatSelectModule,\r\n    // TreeModule,\r\n    // NgbNavModule\r\n  ],\r\n  providers: [\r\n    // MatDatepickerModule,\r\n  ],\r\n  declarations: [\r\n    AlertDialogComponent,\r\n    ConfirmDialogComponent,\r\n    CustomDialogComponent,\r\n    GenericContainerDialogComponent,\r\n    SaveFooterComponent,\r\n    SpinnerDialogComponent\r\n  ],\r\n  entryComponents: [\r\n    AlertDialogComponent,\r\n    ConfirmDialogComponent,\r\n    CustomDialogComponent,\r\n    GenericContainerDialogComponent,\r\n    SaveFooterComponent,\r\n    SpinnerDialogComponent\r\n  ],\r\n  exports: [\r\n    AlertDialogComponent,\r\n    ConfirmDialogComponent,\r\n    CustomDialogComponent,\r\n    GenericContainerDialogComponent,\r\n    SaveFooterComponent,\r\n    SpinnerDialogComponent\r\n  ]\r\n})\r\nexport class DialogModule {\r\n  static forRoot(): ModuleWithProviders<DialogModule> {\r\n    return {\r\n      providers: [\r\n        DialogService\r\n      ],\r\n      ngModule: DialogModule\r\n    };\r\n  }\r\n}\r\n"]}

package/esm2015/generic/generic-container-dialog.component.js

@@ -0,0 +1,158 @@
+import { Component, ElementRef, HostListener, Inject, ViewChild, ChangeDetectorRef, HostBinding } from '@angular/core';
+import { MatDialogRef, MatDialog, MAT_DIALOG_DATA } from '@angular/material/dialog';
+import { Router } from '@angular/router';
+import { ActionType } from '../model/generic-dialog-action.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/router";
+import * as i3 from "ng-dynamic-component";
+import * as i4 from "@angular/common";
+export class GenericContainerDialogComponent {
+    constructor(dialog, router, changeDetector, dialogRef, data) {
+        this.dialog = dialog;
+        this.router = router;
+        this.changeDetector = changeDetector;
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.classList = 'd-flex flex-column flex-grow-1 flex-shrink-1';
+        this.type = ActionType;
+        this.actions = [];
+        this.originalXClick = 0;
+        this.originalYClick = 0;
+        this.positionX = 0;
+        this.positionY = 0;
+        this.movingDialog = false;
+        if (data) {
+            this.dialogContentBluePrint = data.dialogContent;
+            this.icon = data.icon;
+            this.title = data.title;
+            this.useSaveFooter = data.actionConfig ? data.actionConfig.useSaveFooter : false;
+            this.actions = data.actionConfig ? data.actionConfig.actions : [];
+        }
+    }
+    ngOnInit() {
+    }
+    createdComponent(event) {
+        this.dialogContent = event.instance;
+    }
+    executeAction(action) {
+        if (action.externalAction) {
+            action.externalAction();
+        }
+        if (action.internalAction) {
+            const internalAction = action.internalAction;
+            if (action.internalAction === 'cancel' || action.internalAction === 'onClose') {
+                if (this.dialogContent[internalAction]) {
+                    this.dialogContent[internalAction]();
+                }
+                else {
+                    this.onClose();
+                }
+            }
+            else {
+                if (typeof action.internalActionReturnValue !== 'undefined') {
+                    if (action.internalActionReturnValue) {
+                        this.dialogContent[internalAction](action.internalActionReturnValue);
+                    }
+                }
+                else {
+                    this.dialogContent[internalAction]();
+                }
+            }
+        }
+    }
+    onMouseDownHeader(event) {
+        if (!event) {
+            return;
+        }
+        this.positionX = this.topmostLeftmost.nativeElement.offsetLeft;
+        this.positionY = this.topmostLeftmost.nativeElement.offsetTop;
+        this.originalXClick = event.screenX;
+        this.originalYClick = event.screenY;
+        this.movingDialog = true;
+        this.changeDetector.detach();
+    }
+    onMouseMove(event) {
+        if (!event) {
+            return;
+        }
+        if (this.movingDialog) {
+            this.positionX += event.screenX - this.originalXClick;
+            this.positionY += event.screenY - this.originalYClick;
+            this.originalXClick = event.screenX;
+            this.originalYClick = event.screenY;
+            const newDialogPosition = {
+                left: '' + this.positionX + 'px',
+                top: '' + this.positionY + 'px',
+            };
+            this.dialogRef.updatePosition(newDialogPosition);
+        }
+    }
+    onMouseUp() {
+        this.movingDialog = false;
+        this.changeDetector.reattach();
+    }
+    onClose() {
+        this.dialogRef.close();
+    }
+    ngOnDestroy() {
+    }
+}
+GenericContainerDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: GenericContainerDialogComponent, deps: [{ token: i1.MatDialog }, { token: i2.Router }, { token: i0.ChangeDetectorRef }, { token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component });
+GenericContainerDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: GenericContainerDialogComponent, selector: "hci-generic-container-dialog", host: { listeners: { "window:mousemove": "onMouseMove($event)", "window:mouseup": "onMouseUp($event)" }, properties: { "class": "this.classList" } }, viewQueries: [{ propertyName: "topmostLeftmost", first: true, predicate: ["topmostLeftmost"], descendants: true }], ngImport: i0, template: "<div class=\"full-height full-width d-flex flex-column\" style=\"height: 100%;\">\r\n    <div class=\"full-width generic-dialog-header-colors no-margin no-padding\">\r\n        <div #topmostLeftmost mat-dialog-title (mousedown)=\"onMouseDownHeader($event)\"\r\n             class=\"d-flex align-items-center full-width\" [ngClass]=\"{'grabbed':movingDialog, 'grabbable': !movingDialog}\">\r\n            <div class=\"d-flex flex-row align-items-center p-2\">\r\n                <img class=\"icon\" *ngIf=\"icon && icon.substr(0, 2) !== '<i'\" [src]=\"icon\">\r\n                <div *ngIf=\"icon && icon.substr(0, 2) === '<i'\" class=\"i-class\" [innerHTML]=\"icon\" ></div>\r\n                <h3 style=\"margin:0;\">{{this.title ? this.title : this.dialogContent.innerTitle}}</h3>\r\n            </div>\r\n            <div class=\"flex-grow-1\"></div>\r\n            <div class=\"padded\" (click)=\"onClose()\">\r\n                <i class=\"exit fas fa-times\"></i>\r\n            </div>\r\n        </div>\r\n    </div>\r\n\r\n    <mat-dialog-content class=\"flex-grow-1 no-margin no-padding\">\r\n        <div class=\"flex-grow-1 full-height full-width padded\">\r\n            <ndc-dynamic [ndcDynamicComponent]=\"this.dialogContentBluePrint\"\r\n                         [ndcDynamicInputs]=\"this.data\"\r\n                         (ndcDynamicCreated)=\"createdComponent($event)\">\r\n            </ndc-dynamic>\r\n        </div>\r\n    </mat-dialog-content>\r\n    <mat-dialog-actions *ngIf=\"actions && actions.length > 0\"\r\n            class=\"d-flex flex-row justify-content-end no-margin no-padding generic-dialog-footer-colors\">\r\n        <div *ngFor=\"let action of actions\">\r\n            <save-footer *ngIf=\"action.type === type.PRIMARY;else secondary\"\r\n                         [actionType]=\"action.type\"\r\n                         [icon]=\"action.icon\"\r\n                         (saveClicked)=\"executeAction(action)\"\r\n                         [disableSave]=\"this.dialogContent.primaryDisable(action)\"\r\n                         [dirty]=\"this.dialogContent.dirty()\"\r\n                         [name]=\"action.name\"\r\n                         [showSpinner]=\"this.dialogContent.showSpinner\">\r\n            </save-footer>\r\n            <!-- to avoid issue with multiple spinner or dirty notes-->\r\n            <ng-template #secondary>\r\n                <save-footer [actionType]=\"action.type\"\r\n                             (saveClicked)=\"executeAction(action)\"\r\n                             [icon]=\"action.icon\"\r\n                             [disableSave]=\"this.dialogContent.secondaryDisable(action)\"\r\n                             [name]=\"action.name\">\r\n\r\n                </save-footer>\r\n            </ng-template>\r\n        </div>\r\n    </mat-dialog-actions>\r\n</div>\r\n", styles: ["\n\n        .no-padding{\n            padding:0;\n        }\n        .no-margin{\n            margin: 0;\n        }\n        .grabbable {\n            cursor: move;\n            cursor: grab;\n            cursor: -moz-grab;\n            cursor: -webkit-grab;\n        }\n        .grabbed:active {\n            cursor: move;\n            cursor: grabbing;\n            cursor: -moz-grabbing;\n            cursor: -webkit-grabbing;\n        }\n        .exit{\n            max-width: 20px;\n            cursor: pointer;\n        }\n        .i-class {\n            margin-left:  0.3em;\n            margin-right: 0.3em;\n        }\n        mat-dialog-content {\n            max-height: 100% !important;\n        }\n\n    "], components: [{ type: i3.DynamicComponent, selector: "ndc-dynamic", inputs: ["ndcDynamicComponent", "ndcDynamicInjector", "ndcDynamicProviders", "ndcDynamicContent"], outputs: ["ndcDynamicCreated"] }], directives: [{ type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { type: i3.DynamicIoDirective, selector: "[ndcDynamicInputs],[ndcDynamicOutputs],[ngComponentOutletNdcDynamicInputs],[ngComponentOutletNdcDynamicOutputs]", inputs: ["ndcDynamicInputs", "ngComponentOutletNdcDynamicInputs", "ndcDynamicOutputs", "ngComponentOutletNdcDynamicOutputs"] }, { type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]" }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: GenericContainerDialogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'hci-generic-container-dialog',
+                    templateUrl: './generic-container-dialog.component.html',
+                    styles: [`
+
+        .no-padding{
+            padding:0;
+        }
+        .no-margin{
+            margin: 0;
+        }
+        .grabbable {
+            cursor: move;
+            cursor: grab;
+            cursor: -moz-grab;
+            cursor: -webkit-grab;
+        }
+        .grabbed:active {
+            cursor: move;
+            cursor: grabbing;
+            cursor: -moz-grabbing;
+            cursor: -webkit-grabbing;
+        }
+        .exit{
+            max-width: 20px;
+            cursor: pointer;
+        }
+        .i-class {
+            margin-left:  0.3em;
+            margin-right: 0.3em;
+        }
+        mat-dialog-content {
+            max-height: 100% !important;
+        }
+
+    `]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i2.Router }, { type: i0.ChangeDetectorRef }, { type: i1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }]; }, propDecorators: { classList: [{
+                type: HostBinding,
+                args: ['class']
+            }], topmostLeftmost: [{
+                type: ViewChild,
+                args: ['topmostLeftmost', { static: false }]
+            }], onMouseMove: [{
+                type: HostListener,
+                args: ['window:mousemove', ['$event']]
+            }], onMouseUp: [{
+                type: HostListener,
+                args: ['window:mouseup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generic-container-dialog.component.js","sourceRoot":"ng://@huntsman-cancer-institute/dialog/","sources":["generic/generic-container-dialog.component.ts","generic/generic-container-dialog.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    Component,\r\n    ElementRef,\r\n    HostListener,\r\n    Inject,\r\n    OnInit,\r\n    OnDestroy,\r\n    ViewChild, ComponentRef, ChangeDetectorRef, HostBinding\r\n} from '@angular/core';\r\nimport {MatDialogRef, MatDialog, MAT_DIALOG_DATA, DialogPosition} from '@angular/material/dialog';\r\n\r\nimport {Router} from '@angular/router';\r\nimport {BaseGenericContainerDialog} from '../model/base-generic-container-dialog';\r\nimport {ActionType, GDAction} from '../model/generic-dialog-action.model';\r\n\r\n@Component({\r\n    selector: 'hci-generic-container-dialog',\r\n    templateUrl: './generic-container-dialog.component.html',\r\n    styles: [`\r\n\r\n        .no-padding{\r\n            padding:0;\r\n        }\r\n        .no-margin{\r\n            margin: 0;\r\n        }\r\n        .grabbable {\r\n            cursor: move;\r\n            cursor: grab;\r\n            cursor: -moz-grab;\r\n            cursor: -webkit-grab;\r\n        }\r\n        .grabbed:active {\r\n            cursor: move;\r\n            cursor: grabbing;\r\n            cursor: -moz-grabbing;\r\n            cursor: -webkit-grabbing;\r\n        }\r\n        .exit{\r\n            max-width: 20px;\r\n            cursor: pointer;\r\n        }\r\n        .i-class {\r\n            margin-left:  0.3em;\r\n            margin-right: 0.3em;\r\n        }\r\n        mat-dialog-content {\r\n            max-height: 100% !important;\r\n        }\r\n\r\n    `]\r\n})\r\nexport class GenericContainerDialogComponent implements OnInit, OnDestroy {\r\n\r\n    @HostBinding('class') classList = 'd-flex flex-column flex-grow-1 flex-shrink-1';\r\n\r\n    @ViewChild('topmostLeftmost', {static: false}) topmostLeftmost: ElementRef;\r\n\r\n    type = ActionType;\r\n    title: string;\r\n    icon: string;\r\n    dialogContentBluePrint: any;\r\n    actions: GDAction[] = [];\r\n    originalXClick = 0;\r\n    originalYClick = 0;\r\n    dialogContent: BaseGenericContainerDialog;\r\n\r\n    protected positionX = 0;\r\n    protected positionY = 0;\r\n    movingDialog = false;\r\n    useSaveFooter: boolean;\r\n\r\n\r\n    constructor(private dialog: MatDialog,\r\n                private router: Router,\r\n                private changeDetector: ChangeDetectorRef,\r\n                private dialogRef: MatDialogRef<GenericContainerDialogComponent>,\r\n                @Inject(MAT_DIALOG_DATA) public data) {\r\n        if (data) {\r\n            this.dialogContentBluePrint = data.dialogContent;\r\n            this.icon = data.icon;\r\n            this.title = data.title;\r\n            this.useSaveFooter = data.actionConfig ? data.actionConfig.useSaveFooter : false;\r\n            this.actions = data.actionConfig ? data.actionConfig.actions as GDAction[] : [];\r\n        }\r\n    }\r\n\r\n    ngOnInit() {\r\n    }\r\n\r\n    createdComponent(event: ComponentRef<any>) {\r\n        this.dialogContent = (event.instance as BaseGenericContainerDialog);\r\n    }\r\n\r\n    executeAction(action: GDAction): void {\r\n        if (action.externalAction) {\r\n            action.externalAction();\r\n        }\r\n        if (action.internalAction) {\r\n            const internalAction: string = action.internalAction;\r\n            if (action.internalAction === 'cancel' || action.internalAction === 'onClose') {\r\n                if (this.dialogContent[internalAction]) {\r\n                    this.dialogContent[internalAction]();\r\n                } else {\r\n                    this.onClose();\r\n                }\r\n            } else {\r\n              if (typeof action.internalActionReturnValue !== 'undefined') {\r\n                if (action.internalActionReturnValue){\r\n                  this.dialogContent[internalAction](action.internalActionReturnValue);\r\n                }\r\n              }else {\r\n                this.dialogContent[internalAction]();\r\n              }\r\n\r\n            }\r\n        }\r\n    }\r\n\r\n    onMouseDownHeader(event: any): void {\r\n        if (!event) {\r\n            return;\r\n        }\r\n\r\n        this.positionX = this.topmostLeftmost.nativeElement.offsetLeft;\r\n        this.positionY = this.topmostLeftmost.nativeElement.offsetTop;\r\n\r\n        this.originalXClick = event.screenX;\r\n        this.originalYClick = event.screenY;\r\n\r\n        this.movingDialog = true;\r\n        this.changeDetector.detach();\r\n    }\r\n    @HostListener('window:mousemove', ['$event'])\r\n    onMouseMove(event: any): void {\r\n        if (!event) {\r\n            return;\r\n        }\r\n\r\n        if (this.movingDialog) {\r\n            this.positionX += event.screenX - this.originalXClick;\r\n            this.positionY += event.screenY - this.originalYClick;\r\n\r\n            this.originalXClick = event.screenX;\r\n            this.originalYClick = event.screenY;\r\n\r\n            const newDialogPosition: DialogPosition = {\r\n                left:   '' + this.positionX + 'px',\r\n                top:    '' + this.positionY + 'px',\r\n            };\r\n\r\n            this.dialogRef.updatePosition(newDialogPosition);\r\n        }\r\n    }\r\n    @HostListener('window:mouseup', ['$event'])\r\n    onMouseUp(): void {\r\n        this.movingDialog = false;\r\n        this.changeDetector.reattach();\r\n    }\r\n\r\n    onClose() {\r\n        this.dialogRef.close();\r\n    }\r\n\r\n    ngOnDestroy() {\r\n    }\r\n}\r\n","<div class=\"full-height full-width d-flex flex-column\" style=\"height: 100%;\">\r\n    <div class=\"full-width generic-dialog-header-colors no-margin no-padding\">\r\n        <div #topmostLeftmost mat-dialog-title (mousedown)=\"onMouseDownHeader($event)\"\r\n             class=\"d-flex align-items-center full-width\" [ngClass]=\"{'grabbed':movingDialog, 'grabbable': !movingDialog}\">\r\n            <div class=\"d-flex flex-row align-items-center p-2\">\r\n                <img class=\"icon\" *ngIf=\"icon && icon.substr(0, 2) !== '<i'\" [src]=\"icon\">\r\n                <div *ngIf=\"icon && icon.substr(0, 2) === '<i'\" class=\"i-class\" [innerHTML]=\"icon\" ></div>\r\n                <h3 style=\"margin:0;\">{{this.title ? this.title : this.dialogContent.innerTitle}}</h3>\r\n            </div>\r\n            <div class=\"flex-grow-1\"></div>\r\n            <div class=\"padded\" (click)=\"onClose()\">\r\n                <i class=\"exit fas fa-times\"></i>\r\n            </div>\r\n        </div>\r\n    </div>\r\n\r\n    <mat-dialog-content class=\"flex-grow-1 no-margin no-padding\">\r\n        <div class=\"flex-grow-1 full-height full-width padded\">\r\n            <ndc-dynamic [ndcDynamicComponent]=\"this.dialogContentBluePrint\"\r\n                         [ndcDynamicInputs]=\"this.data\"\r\n                         (ndcDynamicCreated)=\"createdComponent($event)\">\r\n            </ndc-dynamic>\r\n        </div>\r\n    </mat-dialog-content>\r\n    <mat-dialog-actions *ngIf=\"actions && actions.length > 0\"\r\n            class=\"d-flex flex-row justify-content-end no-margin no-padding generic-dialog-footer-colors\">\r\n        <div *ngFor=\"let action of actions\">\r\n            <save-footer *ngIf=\"action.type === type.PRIMARY;else secondary\"\r\n                         [actionType]=\"action.type\"\r\n                         [icon]=\"action.icon\"\r\n                         (saveClicked)=\"executeAction(action)\"\r\n                         [disableSave]=\"this.dialogContent.primaryDisable(action)\"\r\n                         [dirty]=\"this.dialogContent.dirty()\"\r\n                         [name]=\"action.name\"\r\n                         [showSpinner]=\"this.dialogContent.showSpinner\">\r\n            </save-footer>\r\n            <!-- to avoid issue with multiple spinner or dirty notes-->\r\n            <ng-template #secondary>\r\n                <save-footer [actionType]=\"action.type\"\r\n                             (saveClicked)=\"executeAction(action)\"\r\n                             [icon]=\"action.icon\"\r\n                             [disableSave]=\"this.dialogContent.secondaryDisable(action)\"\r\n                             [name]=\"action.name\">\r\n\r\n                </save-footer>\r\n            </ng-template>\r\n        </div>\r\n    </mat-dialog-actions>\r\n</div>\r\n"]}

package/esm2015/huntsman-cancer-institute-dialog.js

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHVudHNtYW4tY2FuY2VyLWluc3RpdHV0ZS1kaWFsb2cuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AaHVudHNtYW4tY2FuY2VyLWluc3RpdHV0ZS9kaWFsb2cvIiwic291cmNlcyI6WyJodW50c21hbi1jYW5jZXItaW5zdGl0dXRlLWRpYWxvZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==