@cleavelandprice/ngx-lib 3.0.9 → 3.1.0

package/esm2020/authentication/token/gui/components/login-form/login-form.component.mjs

@@ -0,0 +1,60 @@
+import { Component, Inject } from '@angular/core';
+import { UntypedFormGroup, UntypedFormControl, Validators } from '@angular/forms';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../../services/authentication-token-gui.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/form-field";
+import * as i7 from "@angular/material/icon";
+import * as i8 from "@angular/material/input";
+import * as i9 from "@angular/material/progress-spinner";
+export class LoginFormComponent {
+    constructor(data, dialogRef, authenticationService) {
+        this.dialogRef = dialogRef;
+        this.authenticationService = authenticationService;
+        this.errorMessage = null;
+        this.form = new UntypedFormGroup({
+            username: new UntypedFormControl(null, [Validators.required]),
+            password: new UntypedFormControl(null, [Validators.required]),
+            adminGroup: new UntypedFormControl()
+        });
+        this.form.get('adminGroup')?.setValue(data.adminGroup);
+    }
+    ngOnInit() {
+        this.authenticatedChangedSubscription = this.authenticationService.authenticatedChanged
+            .subscribe(this.authChangedHandler.bind(this));
+        this.authenticationErrorSubscription = this.authenticationService.authenticationError
+            .subscribe(this.errorHandler.bind(this));
+    }
+    ngOnDestroy() {
+        this.authenticationErrorSubscription.unsubscribe();
+        this.authenticatedChangedSubscription.unsubscribe();
+    }
+    authenticate() {
+        this.errorMessage = null;
+        const { username, password, adminGroup } = this.form.value;
+        this.authenticationService.login(username, password, adminGroup);
+    }
+    authChangedHandler(authenticated) {
+        if (authenticated) {
+            this.dialogRef.close();
+        }
+    }
+    errorHandler(err) {
+        console.log('Authentication error', err);
+        this.errorMessage = `${err.name}: ${err.statusText}`;
+    }
+}
+LoginFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: LoginFormComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }, { token: i2.AuthenticationTokenGuiService }], target: i0.ɵɵFactoryTarget.Component });
+LoginFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.1", type: LoginFormComponent, selector: "authentication-login-form", ngImport: i0, template: "<h2 mat-dialog-title>\r\n    <span *ngIf=\"!authenticationService.authenticating\">Login</span>\r\n    <span *ngIf=\"authenticationService.authenticating\">Authenticating...</span>\r\n</h2>\r\n\r\n<mat-dialog-content>\r\n    <div id=\"spinner\" *ngIf=\"authenticationService.authenticating\">\r\n        <mat-progress-spinner color=\"primary\" mode=\"indeterminate\"></mat-progress-spinner>\r\n    </div>\r\n\r\n    <form *ngIf=\"!authenticationService.authenticating\" [formGroup]=\"form\">\r\n        <mat-form-field>\r\n            <input matInput formControlName=\"username\" placeholder=\"Username\" (keyup.enter)=\"authenticate()\">\r\n        </mat-form-field>\r\n\r\n        <mat-form-field>\r\n            <input matInput formControlName=\"password\" type=\"password\" placeholder=\"Password\" (keyup.enter)=\"authenticate()\">\r\n        </mat-form-field>\r\n    </form>\r\n\r\n    <div *ngIf=\"!authenticationService.authenticating && errorMessage\" id=\"error\">\r\n        {{ errorMessage }}\r\n    </div>\r\n</mat-dialog-content>\r\n\r\n<mat-dialog-actions *ngIf=\"!authenticationService.authenticating\">\r\n    <button mat-raised-button color=\"primary\" (click)=\"authenticate()\"\r\n        [disabled]=\"form.invalid\">\r\n        <mat-icon fontIcon=\"done\"></mat-icon>\r\n        <span>OK</span>\r\n    </button>\r\n\r\n    <button mat-raised-button (click)=\"dialogRef.close()\">\r\n        <mat-icon fontIcon=\"close\"></mat-icon>\r\n        <span>Cancel</span>\r\n    </button>\r\n</mat-dialog-actions>", styles: ["#spinner{width:100%;height:100%;display:flex;justify-content:center;align-items:center}form{display:grid;gap:1rem}mat-dialog-actions{display:grid;justify-content:center;grid-template-columns:auto auto;gap:1rem}#error{color:red}\n", ".material-icons{font-family:Material Icons;font-weight:400;font-style:normal;font-size:24px;display:inline-block;line-height:1;text-transform:none;letter-spacing:normal;word-wrap:normal;white-space:nowrap;direction:ltr;-webkit-font-smoothing:antialiased;text-rendering:optimizeLegibility;-moz-osx-font-smoothing:grayscale;font-feature-settings:\"liga\"}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i4.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i4.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i5.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"] }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "directive", type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }, { kind: "component", type: i6.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "component", type: i7.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i8.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i9.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "diameter", "strokeWidth", "mode", "value"], exportAs: ["matProgressSpinner"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: LoginFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'authentication-login-form', template: "<h2 mat-dialog-title>\r\n    <span *ngIf=\"!authenticationService.authenticating\">Login</span>\r\n    <span *ngIf=\"authenticationService.authenticating\">Authenticating...</span>\r\n</h2>\r\n\r\n<mat-dialog-content>\r\n    <div id=\"spinner\" *ngIf=\"authenticationService.authenticating\">\r\n        <mat-progress-spinner color=\"primary\" mode=\"indeterminate\"></mat-progress-spinner>\r\n    </div>\r\n\r\n    <form *ngIf=\"!authenticationService.authenticating\" [formGroup]=\"form\">\r\n        <mat-form-field>\r\n            <input matInput formControlName=\"username\" placeholder=\"Username\" (keyup.enter)=\"authenticate()\">\r\n        </mat-form-field>\r\n\r\n        <mat-form-field>\r\n            <input matInput formControlName=\"password\" type=\"password\" placeholder=\"Password\" (keyup.enter)=\"authenticate()\">\r\n        </mat-form-field>\r\n    </form>\r\n\r\n    <div *ngIf=\"!authenticationService.authenticating && errorMessage\" id=\"error\">\r\n        {{ errorMessage }}\r\n    </div>\r\n</mat-dialog-content>\r\n\r\n<mat-dialog-actions *ngIf=\"!authenticationService.authenticating\">\r\n    <button mat-raised-button color=\"primary\" (click)=\"authenticate()\"\r\n        [disabled]=\"form.invalid\">\r\n        <mat-icon fontIcon=\"done\"></mat-icon>\r\n        <span>OK</span>\r\n    </button>\r\n\r\n    <button mat-raised-button (click)=\"dialogRef.close()\">\r\n        <mat-icon fontIcon=\"close\"></mat-icon>\r\n        <span>Cancel</span>\r\n    </button>\r\n</mat-dialog-actions>", styles: ["#spinner{width:100%;height:100%;display:flex;justify-content:center;align-items:center}form{display:grid;gap:1rem}mat-dialog-actions{display:grid;justify-content:center;grid-template-columns:auto auto;gap:1rem}#error{color:red}\n", ".material-icons{font-family:Material Icons;font-weight:400;font-style:normal;font-size:24px;display:inline-block;line-height:1;text-transform:none;letter-spacing:normal;word-wrap:normal;white-space:nowrap;direction:ltr;-webkit-font-smoothing:antialiased;text-rendering:optimizeLegibility;-moz-osx-font-smoothing:grayscale;font-feature-settings:\"liga\"}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }, { type: i1.MatDialogRef }, { type: i2.AuthenticationTokenGuiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/authentication/token/gui/model/default-config.mjs

@@ -0,0 +1,6 @@
+export const defaultConfig = {
+    apiUrl: 'http://utilityapi/authenticate/token',
+    tokenName: 'token',
+    deferTokenValidation: true
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYi9hdXRoZW50aWNhdGlvbi90b2tlbi9ndWkvc3JjL21vZGVsL2RlZmF1bHQtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBa0I7SUFDeEMsTUFBTSxFQUFFLHNDQUFzQztJQUM5QyxTQUFTLEVBQUUsT0FBTztJQUNsQixvQkFBb0IsRUFBRSxJQUFJO0NBQzdCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZXJ2aWNlQ29uZmlnIH0gZnJvbSAnQGNsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2F1dGhlbnRpY2F0aW9uL3Rva2VuJztcclxuXHJcbmV4cG9ydCBjb25zdCBkZWZhdWx0Q29uZmlnOiBTZXJ2aWNlQ29uZmlnID0ge1xyXG4gICAgYXBpVXJsOiAnaHR0cDovL3V0aWxpdHlhcGkvYXV0aGVudGljYXRlL3Rva2VuJyxcclxuICAgIHRva2VuTmFtZTogJ3Rva2VuJyxcclxuICAgIGRlZmVyVG9rZW5WYWxpZGF0aW9uOiB0cnVlXHJcbn0iXX0=

package/esm2020/authentication/token/gui/model/login-form-data.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9naW4tZm9ybS1kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2xlYXZlbGFuZHByaWNlL25neC1saWIvYXV0aGVudGljYXRpb24vdG9rZW4vZ3VpL3NyYy9tb2RlbC9sb2dpbi1mb3JtLWRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgTG9naW5Gb3JtRGF0YSB7XHJcbiAgICBhZG1pbkdyb3VwOiBzdHJpbmc7XHJcbn1cclxuIl19

package/esm2020/authentication/token/gui/model/service-config.mjs

@@ -0,0 +1,4 @@
+import { ServiceConfig as BaseServiceConfig } from '@cleavelandprice/ngx-lib/authentication/token';
+export class ServiceConfig extends BaseServiceConfig {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYi9hdXRoZW50aWNhdGlvbi90b2tlbi9ndWkvc3JjL21vZGVsL3NlcnZpY2UtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLElBQUksaUJBQWlCLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUVuRyxNQUFNLE9BQU8sYUFBYyxTQUFRLGlCQUFpQjtDQUNuRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNlcnZpY2VDb25maWcgYXMgQmFzZVNlcnZpY2VDb25maWcgfSBmcm9tICdAY2xlYXZlbGFuZHByaWNlL25neC1saWIvYXV0aGVudGljYXRpb24vdG9rZW4nO1xyXG5cclxuZXhwb3J0IGNsYXNzIFNlcnZpY2VDb25maWcgZXh0ZW5kcyBCYXNlU2VydmljZUNvbmZpZyB7XHJcbn0iXX0=

package/esm2020/authentication/token/gui/public_api.mjs

@@ -0,0 +1,8 @@
+export * from './model/default-config';
+export * from './model/login-form-data';
+export * from './model/service-config';
+export * from './services/authentication-token-gui.service';
+export * from './components/login/login.component';
+export * from './components/login-form/login-form.component';
+export * from './authentication-token-gui.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2F1dGhlbnRpY2F0aW9uL3Rva2VuL2d1aS9zcmMvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxjQUFjLDZDQUE2QyxDQUFDO0FBRTVELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyw4Q0FBOEMsQ0FBQztBQUU3RCxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tb2RlbC9kZWZhdWx0LWNvbmZpZyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWwvbG9naW4tZm9ybS1kYXRhJztcclxuZXhwb3J0ICogZnJvbSAnLi9tb2RlbC9zZXJ2aWNlLWNvbmZpZyc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2F1dGhlbnRpY2F0aW9uLXRva2VuLWd1aS5zZXJ2aWNlJztcclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9sb2dpbi9sb2dpbi5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvbG9naW4tZm9ybS9sb2dpbi1mb3JtLmNvbXBvbmVudCc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2F1dGhlbnRpY2F0aW9uLXRva2VuLWd1aS5tb2R1bGUnOyJdfQ==

package/esm2020/authentication/token/gui/services/authentication-token-gui.service.mjs

@@ -0,0 +1,74 @@
+import { Injectable, Optional } from '@angular/core';
+import { JwtHelperService } from '@auth0/angular-jwt';
+import { AuthenticationTokenService } from '@cleavelandprice/ngx-lib/authentication/token';
+import { defaultConfig } from '../model/default-config';
+import * as i0 from "@angular/core";
+import * as i1 from "../model/service-config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "@cleavelandprice/ngx-lib/sharepoint";
+export class AuthenticationTokenGuiService extends AuthenticationTokenService {
+    //#region Lifecycle
+    // If a ServiceConfig object is not provided when the module is imported, then default values are pulled in from default-config.ts.
+    constructor(config, http, sharePointService) {
+        config = {
+            ...defaultConfig,
+            ...config,
+            // Need to force deferTokenValidation here because if a custom config was passed in, deferTokenValidation would have defaulted to false since it's the default boolean value
+            // If a custom config wasn't passed in, then deferTokenValidation would have been true from defaultConfig
+            deferTokenValidation: true
+        };
+        super(config, http);
+        this.config = config;
+        this.http = http;
+        this.sharePointService = sharePointService;
+        this.checkForExistingToken();
+    }
+    //#endregion
+    //#region Utilities
+    validateUser(token) {
+        const jwtHelper = new JwtHelperService();
+        const decoded = jwtHelper.decodeToken(token);
+        if (jwtHelper.isTokenExpired(token)) {
+            this.logout();
+            return;
+        }
+        this.authenticatedUser = {
+            admin: decoded.role === 'Admin',
+            displayName: decoded.displayName,
+            accountName: decoded.winaccountname,
+            distinguishedName: decoded.distinguishedName,
+            employeeNumber: decoded.employeeNumber,
+            memberOf: decoded.memberOf
+        };
+        localStorage.setItem(this.config.tokenName, token);
+        this.getPhoto();
+        this.authenticated = true;
+        this.authenticatedChanged.emit(this.authenticated);
+        this.authenticating = false;
+        this.authenticatingChanged.emit(this.authenticating);
+    }
+    getPhoto() {
+        this.sharePointService.getPhotos()
+            .subscribe(photos => {
+            // The user may have been logged out by the time the photos came back
+            if (!this.authenticatedUser?.employeeNumber) {
+                return;
+            }
+            const photo = photos.find(pic => pic.employeeNumber === +this.authenticatedUser.employeeNumber);
+            if (photo) {
+                this.authenticatedUser.photoUrl = photo.encodedAbsUrl;
+            }
+        });
+    }
+}
+AuthenticationTokenGuiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: AuthenticationTokenGuiService, deps: [{ token: i1.ServiceConfig, optional: true }, { token: i2.HttpClient }, { token: i3.SharePointService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthenticationTokenGuiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: AuthenticationTokenGuiService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: AuthenticationTokenGuiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ServiceConfig, decorators: [{
+                    type: Optional
+                }] }, { type: i2.HttpClient }, { type: i3.SharePointService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/authentication/token/model/authentication-token.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aGVudGljYXRpb24tdG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYi9hdXRoZW50aWNhdGlvbi90b2tlbi9zcmMvbW9kZWwvYXV0aGVudGljYXRpb24tdG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQXV0aGVudGljYXRpb25Ub2tlbiB7XHJcbiAgICBhdWQ6IHN0cmluZztcclxuICAgIGRpc3BsYXlOYW1lOiBzdHJpbmc7XHJcbiAgICBkaXN0aW5ndWlzaGVkTmFtZTogc3RyaW5nO1xyXG4gICAgZW1haWw6IHN0cmluZztcclxuICAgIGVtcGxveWVlTnVtYmVyOiBzdHJpbmc7XHJcbiAgICBleHA6IG51bWJlcjtcclxuICAgIGZpcnN0TmFtZTogc3RyaW5nO1xyXG4gICAgaXNzOiBzdHJpbmc7XHJcbiAgICBsYXN0TmFtZTogc3RyaW5nO1xyXG4gICAgbWVtYmVyT2Y6IHN0cmluZztcclxuICAgIG5iZjogbnVtYmVyO1xyXG4gICAgcGhvbmU6IHN0cmluZztcclxuICAgIHJvbGU6IHN0cmluZztcclxuICAgIHNpZDogc3RyaW5nO1xyXG4gICAgd2luYWNjb3VudG5hbWU6IHN0cmluZztcclxufVxyXG4iXX0=

package/esm2020/authentication/token/model/default-config.mjs

@@ -0,0 +1,6 @@
+export const defaultConfig = {
+    apiUrl: 'http://utilityapi/authenticate/token',
+    tokenName: 'token',
+    deferTokenValidation: false
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYi9hdXRoZW50aWNhdGlvbi90b2tlbi9zcmMvbW9kZWwvZGVmYXVsdC1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFrQjtJQUN4QyxNQUFNLEVBQUUsc0NBQXNDO0lBQzlDLFNBQVMsRUFBRSxPQUFPO0lBQ2xCLG9CQUFvQixFQUFFLEtBQUs7Q0FDOUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNlcnZpY2VDb25maWcgfSBmcm9tICcuL3NlcnZpY2UtY29uZmlnJztcclxuXHJcbmV4cG9ydCBjb25zdCBkZWZhdWx0Q29uZmlnOiBTZXJ2aWNlQ29uZmlnID0ge1xyXG4gICAgYXBpVXJsOiAnaHR0cDovL3V0aWxpdHlhcGkvYXV0aGVudGljYXRlL3Rva2VuJyxcclxuICAgIHRva2VuTmFtZTogJ3Rva2VuJyxcclxuICAgIGRlZmVyVG9rZW5WYWxpZGF0aW9uOiBmYWxzZVxyXG59Il19

package/esm2020/authentication/token/model/service-config.mjs

@@ -0,0 +1,4 @@
+import { ServiceConfig as BaseServiceConfig } from '@cleavelandprice/ngx-lib/authentication';
+export class ServiceConfig extends BaseServiceConfig {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYi9hdXRoZW50aWNhdGlvbi90b2tlbi9zcmMvbW9kZWwvc2VydmljZS1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsSUFBSSxpQkFBaUIsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBRTdGLE1BQU0sT0FBTyxhQUFjLFNBQVEsaUJBQWlCO0NBRW5EIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VydmljZUNvbmZpZyBhcyBCYXNlU2VydmljZUNvbmZpZyB9IGZyb20gJ0BjbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYi9hdXRoZW50aWNhdGlvbic7XHJcblxyXG5leHBvcnQgY2xhc3MgU2VydmljZUNvbmZpZyBleHRlbmRzIEJhc2VTZXJ2aWNlQ29uZmlnIHtcclxuICAgIGRlZmVyVG9rZW5WYWxpZGF0aW9uITogYm9vbGVhbjtcclxufSJdfQ==

package/esm2020/authentication/token/public_api.mjs

@@ -0,0 +1,6 @@
+export * from './model/authentication-token';
+export * from './model/default-config';
+export * from './model/service-config';
+export * from './services/authentication-token.service';
+export * from './authentication-token.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2F1dGhlbnRpY2F0aW9uL3Rva2VuL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHdCQUF3QixDQUFDO0FBRXZDLGNBQWMseUNBQXlDLENBQUM7QUFFeEQsY0FBYywrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9kZWwvYXV0aGVudGljYXRpb24tdG9rZW4nO1xyXG5leHBvcnQgKiBmcm9tICcuL21vZGVsL2RlZmF1bHQtY29uZmlnJztcclxuZXhwb3J0ICogZnJvbSAnLi9tb2RlbC9zZXJ2aWNlLWNvbmZpZyc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2F1dGhlbnRpY2F0aW9uLXRva2VuLnNlcnZpY2UnO1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9hdXRoZW50aWNhdGlvbi10b2tlbi5tb2R1bGUnOyJdfQ==

package/esm2020/authentication/token/services/authentication-token.service.mjs

@@ -0,0 +1,112 @@
+import { EventEmitter, Injectable, Optional, Output } from '@angular/core';
+import { JwtHelperService } from '@auth0/angular-jwt';
+import { defaultConfig } from '../model/default-config';
+import * as i0 from "@angular/core";
+import * as i1 from "../model/service-config";
+import * as i2 from "@angular/common/http";
+export class AuthenticationTokenService {
+    //#endregion
+    //#region Lifecycle
+    // If a ServiceConfig object is not provided when the module is imported, then default values are pulled in from default-config.ts.
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+        //#region Fields
+        this.authenticatedChanged = new EventEmitter();
+        this.authenticatingChanged = new EventEmitter();
+        this.authenticationError = new EventEmitter();
+        this.authenticating = false; // Flag set to true while the service is attempting to authenticate the user
+        this.authenticated = false; // Flag set to true when the user is successfully authenticated
+        this.authenticatedUser = null; // Object representing the authenticated user
+        this.config = {
+            ...defaultConfig,
+            ...config
+        };
+        if (!this.config.deferTokenValidation) {
+            this.checkForExistingToken();
+        }
+    }
+    //#endregion
+    //#region Utilities
+    //Authenticate the user and store the token in Local Storage
+    login(username, password, adminGroup) {
+        const request = {
+            username: username,
+            password: password,
+            adminGroup: adminGroup
+        };
+        this.authenticating = true;
+        this.authenticatingChanged.emit(this.authenticating);
+        // Sending a 'raw' POST request so that we can tell HttpClient that we are expecting text instead of Json
+        // Otherwise, it would throw an error trying to decode Json from the response
+        this.http.request('POST', this.config.apiUrl, { body: request, responseType: 'text' })
+            .subscribe({
+            next: (token) => {
+                if (token) {
+                    this.validateUser(token);
+                }
+                else {
+                    this.logout();
+                }
+            },
+            error: (err) => {
+                this.authenticating = false;
+                this.authenticatingChanged.emit(this.authenticating);
+                this.authenticationError.emit(err);
+            }
+        });
+    }
+    //Logout the user and delete the token from Local Storage
+    logout() {
+        if (localStorage.getItem(this.config.tokenName)) {
+            localStorage.removeItem(this.config.tokenName);
+        }
+        this.authenticatedUser = null;
+        this.authenticated = false;
+        this.authenticatedChanged.emit(false);
+    }
+    validateUser(token) {
+        const jwtHelper = new JwtHelperService();
+        const decoded = jwtHelper.decodeToken(token);
+        if (jwtHelper.isTokenExpired(token)) {
+            this.logout();
+            return;
+        }
+        this.authenticatedUser = {
+            admin: decoded.role === 'Admin',
+            displayName: decoded.displayName,
+            accountName: decoded.winaccountname,
+            distinguishedName: decoded.distinguishedName,
+            employeeNumber: decoded.employeeNumber,
+            memberOf: decoded.memberOf
+        };
+        localStorage.setItem(this.config.tokenName, token);
+        this.authenticated = true;
+        this.authenticatedChanged.emit(this.authenticated);
+        this.authenticating = false;
+        this.authenticatingChanged.emit(this.authenticating);
+    }
+    checkForExistingToken() {
+        const token = localStorage.getItem(this.config.tokenName);
+        if (token) {
+            this.validateUser(token);
+        }
+    }
+}
+AuthenticationTokenService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: AuthenticationTokenService, deps: [{ token: i1.ServiceConfig, optional: true }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthenticationTokenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: AuthenticationTokenService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: AuthenticationTokenService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ServiceConfig, decorators: [{
+                    type: Optional
+                }] }, { type: i2.HttpClient }]; }, propDecorators: { authenticatedChanged: [{
+                type: Output
+            }], authenticatingChanged: [{
+                type: Output
+            }], authenticationError: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authentication-token.service.js","sourceRoot":"","sources":["../../../../../../../projects/cleavelandprice/ngx-lib/authentication/token/src/services/authentication-token.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAStD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;;;;AAMxD,MAAM,OAAO,0BAA0B;IAQrC,YAAY;IAEZ,mBAAmB;IACnB,mIAAmI;IACnI,YAAkC,MAAqB,EACjC,IAAgB;QADJ,WAAM,GAAN,MAAM,CAAe;QACjC,SAAI,GAAJ,IAAI,CAAY;QAZtC,gBAAgB;QACN,yBAAoB,GAAG,IAAI,YAAY,EAAW,CAAC;QACnD,0BAAqB,GAAG,IAAI,YAAY,EAAW,CAAC;QACpD,wBAAmB,GAAG,IAAI,YAAY,EAAE,CAAC;QACnD,mBAAc,GAAG,KAAK,CAAC,CAAC,4EAA4E;QACpG,kBAAa,GAAG,KAAK,CAAC,CAAC,+DAA+D;QACtF,sBAAiB,GAA6B,IAAI,CAAC,CAAC,6CAA6C;QAQnF,IAAI,CAAC,MAAM,GAAG;YACZ,GAAG,aAAa;YAChB,GAAG,MAAM;SACV,CAAC;QAEF,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,oBAAoB,EAAE;YACrC,IAAI,CAAC,qBAAqB,EAAE,CAAC;SAC9B;IACf,CAAC;IACD,YAAY;IAEZ,mBAAmB;IACnB,4DAA4D;IAC5D,KAAK,CAAC,QAAgB,EAAE,QAAgB,EAAE,UAAmB;QAC3D,MAAM,OAAO,GAA0B;YACrC,QAAQ,EAAE,QAAQ;YAClB,QAAQ,EAAE,QAAQ;YAClB,UAAU,EAAE,UAAU;SACvB,CAAC;QAEF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAErD,yGAAyG;QACzG,6EAA6E;QAC7E,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;aACnF,SAAS,CAAC;YACT,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE;gBACd,IAAI,KAAK,EAAE;oBACT,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;iBAC1B;qBAAM;oBACL,IAAI,CAAC,MAAM,EAAE,CAAC;iBACf;YACH,CAAC;YACD,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;gBACb,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;gBAC5B,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBACrD,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACrC,CAAC;SACF,CAAC,CAAC;IACP,CAAC;IAED,yDAAyD;IACzD,MAAM;QACJ,IAAI,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE;YAC/C,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;SAChD;QAED,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC3B,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,YAAY,CAAC,KAAa;QACxB,MAAM,SAAS,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACzC,MAAM,OAAO,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAwB,CAAC;QAEpE,IAAI,SAAS,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE;YACnC,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,OAAO;SACR;QAED,IAAI,CAAC,iBAAiB,GAAG;YACvB,KAAK,EAAE,OAAO,CAAC,IAAI,KAAK,OAAO;YAC/B,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,WAAW,EAAE,OAAO,CAAC,cAAc;YACnC,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;YAC5C,cAAc,EAAE,OAAO,CAAC,cAAc;YACtC,QAAQ,EAAE,OAAO,CAAC,QAAQ;SAC3B,CAAC;QAEF,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAEnD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAEnD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACvD,CAAC;IAED,qBAAqB;QACnB,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC1D,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;SAC1B;IACH,CAAC;;uHApGU,0BAA0B;2HAA1B,0BAA0B,cAFzB,MAAM;2FAEP,0BAA0B;kBAHtC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAac,QAAQ;qEAVX,oBAAoB;sBAA7B,MAAM;gBACG,qBAAqB;sBAA9B,MAAM;gBACG,mBAAmB;sBAA5B,MAAM","sourcesContent":["import { EventEmitter, Injectable, Optional, Output } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { JwtHelperService } from '@auth0/angular-jwt';\r\n\r\nimport {\r\n  AbstractAuthenticationService,\r\n  AuthenticatedUser,\r\n  AuthenticationRequest\r\n} from '@cleavelandprice/ngx-lib/authentication';\r\n\r\nimport { AuthenticationToken } from '../model/authentication-token';\r\nimport { defaultConfig } from '../model/default-config';\r\nimport { ServiceConfig } from '../model/service-config';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AuthenticationTokenService implements AbstractAuthenticationService {\r\n  //#region Fields\r\n  @Output() authenticatedChanged = new EventEmitter<boolean>();\r\n  @Output() authenticatingChanged = new EventEmitter<boolean>();\r\n  @Output() authenticationError = new EventEmitter();\r\n  authenticating = false; // Flag set to true while the service is attempting to authenticate the user\r\n  authenticated = false; // Flag set to true when the user is successfully authenticated\r\n  authenticatedUser: AuthenticatedUser | null = null; // Object representing the authenticated user\r\n  //#endregion\r\n\r\n  //#region Lifecycle\r\n  // If a ServiceConfig object is not provided when the module is imported, then default values are pulled in from default-config.ts.\r\n  constructor(@Optional() protected config: ServiceConfig,\r\n              protected http: HttpClient) {\r\n\r\n                this.config = {\r\n                  ...defaultConfig,\r\n                  ...config\r\n                };\r\n\r\n                if (!this.config.deferTokenValidation) {\r\n                  this.checkForExistingToken();\r\n                }\r\n  }\r\n  //#endregion\r\n\r\n  //#region Utilities\r\n  //Authenticate the user and store the token in Local Storage\r\n  login(username: string, password: string, adminGroup?: string): void {\r\n    const request: AuthenticationRequest = {\r\n      username: username,\r\n      password: password,\r\n      adminGroup: adminGroup\r\n    };\r\n\r\n    this.authenticating = true;\r\n    this.authenticatingChanged.emit(this.authenticating);\r\n\r\n    // Sending a 'raw' POST request so that we can tell HttpClient that we are expecting text instead of Json\r\n    // Otherwise, it would throw an error trying to decode Json from the response\r\n    this.http.request('POST', this.config.apiUrl, { body: request, responseType: 'text' })\r\n      .subscribe({\r\n        next: (token) => {\r\n          if (token) {\r\n            this.validateUser(token);\r\n          } else {\r\n            this.logout();\r\n          }\r\n        },\r\n        error: (err) => {\r\n          this.authenticating = false;\r\n          this.authenticatingChanged.emit(this.authenticating);\r\n          this.authenticationError.emit(err);\r\n        }\r\n      });\r\n  }\r\n \r\n  //Logout the user and delete the token from Local Storage\r\n  logout(): void {\r\n    if (localStorage.getItem(this.config.tokenName)) {\r\n      localStorage.removeItem(this.config.tokenName);\r\n    }\r\n\r\n    this.authenticatedUser = null;\r\n    this.authenticated = false;\r\n    this.authenticatedChanged.emit(false);\r\n  }\r\n \r\n  validateUser(token: string): void {\r\n    const jwtHelper = new JwtHelperService();\r\n    const decoded = jwtHelper.decodeToken(token) as AuthenticationToken;\r\n\r\n    if (jwtHelper.isTokenExpired(token)) {\r\n      this.logout();\r\n      return;\r\n    }\r\n\r\n    this.authenticatedUser = {\r\n      admin: decoded.role === 'Admin',\r\n      displayName: decoded.displayName,\r\n      accountName: decoded.winaccountname,\r\n      distinguishedName: decoded.distinguishedName,\r\n      employeeNumber: decoded.employeeNumber,\r\n      memberOf: decoded.memberOf\r\n    };\r\n\r\n    localStorage.setItem(this.config.tokenName, token);\r\n    \r\n    this.authenticated = true;\r\n    this.authenticatedChanged.emit(this.authenticated);\r\n\r\n    this.authenticating = false;\r\n    this.authenticatingChanged.emit(this.authenticating);\r\n  }\r\n\r\n  checkForExistingToken(): void {\r\n    const token = localStorage.getItem(this.config.tokenName);\r\n    if (token) {\r\n      this.validateUser(token);\r\n    }\r\n  }\r\n  //#endregion\r\n}"]}

package/esm2020/dialog/components/base/base.component.mjs

@@ -74,9 +74,9 @@ export class BaseComponent {
         this.closed.emit(data);
     }
 }
-BaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: BaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-BaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: BaseComponent, selector: "dialog-base", inputs: { dialogType: "dialogType", data: "data" }, outputs: { closed: "closed" }, ngImport: i0, template: "<h2 *ngIf=\"data?.title\" mat-dialog-title [innerHTML]=\"data.title\"></h2>\n\n<mat-dialog-content>\n    <div *ngIf=\"data?.message\" [innerHTML]=\"data.message\"></div>\n\n    <mat-form-field *ngIf=\"dialogType === DialogType.Input\">\n        <textarea matInput [placeholder]=\"data.placeholder ?? ''\" [(ngModel)]=\"userInput\"></textarea>\n    </mat-form-field>\n\n    <div id=\"checkbox\" *ngIf=\"data?.checkboxMessage\">\n        <mat-checkbox [(ngModel)]=\"checkboxValue\">\n            <span [innerHTML]=\"data.checkboxMessage\"></span>\n        </mat-checkbox>\n    </div>\n</mat-dialog-content>\n\n<mat-dialog-actions>\n    <ng-container *ngIf=\"dialogType !== DialogType.Choice\">\n        <button mat-raised-button (click)=\"close()\" [disabled]=\"dialogType === DialogType.Input && !userInput\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">Yes</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">True</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customTrueText }}</span>\n                <span *ngSwitchDefault>OK</span>\n            </span>\n        </button>\n        <button *ngIf=\"dialogType !== DialogType.Message\" mat-raised-button (click)=\"cancel()\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">No</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">False</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customFalseText }}</span>\n                <span *ngSwitchDefault>Cancel</span>\n            </span>\n        </button>\n    </ng-container>\n\n    <ng-container *ngIf=\"dialogType === DialogType.Choice\">\n        <button mat-raised-button *ngFor=\"let choice of choices; let i = index\" [matDialogClose]=\"i\">\n            <span>{{ choice }}</span>\n        </button>\n    </ng-container>\n</mat-dialog-actions>", styles: ["mat-form-field{margin-top:2em;width:100%}#checkbox{margin:2em 0}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i1.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i1.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i3.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"] }, { kind: "component", type: i4.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex"], exportAs: ["matCheckbox"] }, { kind: "directive", type: i5.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "directive", type: i5.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i5.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "directive", type: i5.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }, { kind: "component", type: i6.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: BaseComponent, decorators: [{
+BaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: BaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.1", type: BaseComponent, selector: "dialog-base", inputs: { dialogType: "dialogType", data: "data" }, outputs: { closed: "closed" }, ngImport: i0, template: "<h2 *ngIf=\"data?.title\" mat-dialog-title [innerHTML]=\"data.title\"></h2>\n\n<mat-dialog-content>\n    <div *ngIf=\"data?.message\" [innerHTML]=\"data.message\"></div>\n\n    <mat-form-field *ngIf=\"dialogType === DialogType.Input\">\n        <textarea matInput [placeholder]=\"data.placeholder ?? ''\" [(ngModel)]=\"userInput\"></textarea>\n    </mat-form-field>\n\n    <div id=\"checkbox\" *ngIf=\"data?.checkboxMessage\">\n        <mat-checkbox [(ngModel)]=\"checkboxValue\">\n            <span [innerHTML]=\"data.checkboxMessage\"></span>\n        </mat-checkbox>\n    </div>\n</mat-dialog-content>\n\n<mat-dialog-actions>\n    <ng-container *ngIf=\"dialogType !== DialogType.Choice\">\n        <button mat-raised-button (click)=\"close()\" [disabled]=\"dialogType === DialogType.Input && !userInput\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">Yes</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">True</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customTrueText }}</span>\n                <span *ngSwitchDefault>OK</span>\n            </span>\n        </button>\n        <button *ngIf=\"dialogType !== DialogType.Message\" mat-raised-button (click)=\"cancel()\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">No</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">False</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customFalseText }}</span>\n                <span *ngSwitchDefault>Cancel</span>\n            </span>\n        </button>\n    </ng-container>\n\n    <ng-container *ngIf=\"dialogType === DialogType.Choice\">\n        <button mat-raised-button *ngFor=\"let choice of choices; let i = index\" [matDialogClose]=\"i\">\n            <span>{{ choice }}</span>\n        </button>\n    </ng-container>\n</mat-dialog-actions>", styles: ["mat-form-field{margin-top:2em;width:100%}#checkbox{margin:2em 0}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i1.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i1.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i3.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"] }, { kind: "component", type: i4.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex"], exportAs: ["matCheckbox"] }, { kind: "directive", type: i5.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "directive", type: i5.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i5.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "directive", type: i5.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }, { kind: "component", type: i6.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: BaseComponent, decorators: [{
             type: Component,
             args: [{ selector: 'dialog-base', template: "<h2 *ngIf=\"data?.title\" mat-dialog-title [innerHTML]=\"data.title\"></h2>\n\n<mat-dialog-content>\n    <div *ngIf=\"data?.message\" [innerHTML]=\"data.message\"></div>\n\n    <mat-form-field *ngIf=\"dialogType === DialogType.Input\">\n        <textarea matInput [placeholder]=\"data.placeholder ?? ''\" [(ngModel)]=\"userInput\"></textarea>\n    </mat-form-field>\n\n    <div id=\"checkbox\" *ngIf=\"data?.checkboxMessage\">\n        <mat-checkbox [(ngModel)]=\"checkboxValue\">\n            <span [innerHTML]=\"data.checkboxMessage\"></span>\n        </mat-checkbox>\n    </div>\n</mat-dialog-content>\n\n<mat-dialog-actions>\n    <ng-container *ngIf=\"dialogType !== DialogType.Choice\">\n        <button mat-raised-button (click)=\"close()\" [disabled]=\"dialogType === DialogType.Input && !userInput\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">Yes</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">True</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customTrueText }}</span>\n                <span *ngSwitchDefault>OK</span>\n            </span>\n        </button>\n        <button *ngIf=\"dialogType !== DialogType.Message\" mat-raised-button (click)=\"cancel()\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">No</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">False</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customFalseText }}</span>\n                <span *ngSwitchDefault>Cancel</span>\n            </span>\n        </button>\n    </ng-container>\n\n    <ng-container *ngIf=\"dialogType === DialogType.Choice\">\n        <button mat-raised-button *ngFor=\"let choice of choices; let i = index\" [matDialogClose]=\"i\">\n            <span>{{ choice }}</span>\n        </button>\n    </ng-container>\n</mat-dialog-actions>", styles: ["mat-form-field{margin-top:2em;width:100%}#checkbox{margin:2em 0}\n"] }]
         }], propDecorators: { dialogType: [{
@@ -86,4 +86,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImpor
             }], closed: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.component.js","sourceRoot":"","sources":["../../../../../../../projects/cleavelandprice/ngx-lib/dialog/src/components/base/base.component.ts","../../../../../../../projects/cleavelandprice/ngx-lib/dialog/src/components/base/base.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAG9E,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;;;;;;;;;AAOrD,MAAM,OAAO,aAAa;IAL1B;QAME,8EAA8E;QAC9E,eAAU,GAAG,UAAU,CAAC;QACf,eAAU,GAAG,UAAU,CAAC,OAAO,CAAC;QAE/B,WAAM,GAAG,IAAI,YAAY,EAAO,CAAC;QAE3C,2BAAsB,GAAG,sBAAsB,CAAC;KAsEjD;IAhEC,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACpC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC;IACT,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACpC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC;IACT,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,UAAU,KAAK,UAAU,CAAC,MAAM,CAAC,CAAC;YAC3C,IAAI,CAAC,IAAyB,CAAC,OAAO,CAAC,CAAC;YACzC,IAAI,CAAC;IACT,CAAC;IAED,KAAK;QACH,IAAI,IAAS,CAAC;QAEd,QAAQ,IAAI,CAAC,UAAU,EAAE;YACrB,KAAK,UAAU,CAAC,OAAO;gBACnB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;oBAC9B;wBACI,QAAQ,EAAE,IAAI,CAAC,aAAa,IAAI,KAAK;qBACxC,CAAC,CAAC;oBACH,IAAI,CAAC;gBACT,MAAM;YACV,KAAK,UAAU,CAAC,KAAK;gBACjB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;oBAC9B;wBACI,QAAQ,EAAE,IAAI,CAAC,SAAS;wBACxB,QAAQ,EAAE,IAAI,CAAC,aAAa,IAAI,KAAK;qBACxC,CAAC,CAAC;oBACH,IAAI,CAAC,SAAS,CAAC;gBACnB,MAAM;YACV,KAAK,UAAU,CAAC,YAAY;gBACxB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;oBAC9B;wBACI,QAAQ,EAAE,IAAI;wBACd,QAAQ,EAAE,IAAI,CAAC,aAAa,IAAI,KAAK;qBACxC,CAAC,CAAC;oBACH,IAAI,CAAC;gBACT,MAAM;SACb;QAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAED,MAAM;QACJ,IAAI,IAAS,CAAC;QAEd,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,CAAC,YAAY,EAAE;YAC7C,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gBAC9B;oBACI,QAAQ,EAAE,KAAK;oBACf,QAAQ,EAAE,IAAI,CAAC,aAAa,IAAI,KAAK;iBACxC,CAAC,CAAC;gBACH,KAAK,CAAC;SACb;QAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;;0GA5EU,aAAa;8FAAb,aAAa,sICX1B,69DAyCqB;2FD9BR,aAAa;kBALzB,SAAS;+BACE,aAAa;8BAOd,UAAU;sBAAlB,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACI,MAAM;sBAAf,MAAM","sourcesContent":["import { Component, Input, Output, EventEmitter } from '@angular/core';\nimport { ConfirmationDialogMode } from '../../model/confirmation-dialog-mode';\nimport { DialogBaseData } from '../../model/dialog-base-data';\nimport { DialogChoiceData } from '../../model/dialog-choice-data';\nimport { DialogType } from '../../model/dialog-type';\n\n@Component({\n  selector: 'dialog-base',\n  templateUrl: './base.component.html',\n  styleUrls: ['./base.component.css']\n})\nexport class BaseComponent {\n  // This is so that DialogType can be publish accessible from the HTML template\n  DialogType = DialogType;\n  @Input() dialogType = DialogType.Message;\n  @Input() data!: DialogBaseData;\n  @Output() closed = new EventEmitter<any>();\n\n  ConfirmationDialogMode = ConfirmationDialogMode;\n\n  // Form values\n  userInput!: string;\n  checkboxValue!: boolean;\n\n  get customTrueText(): string | null {\n    return this.data.customTrueFalseText ?\n      this.data.customTrueFalseText[0] :\n      null;\n  }\n\n  get customFalseText(): string | null {\n    return this.data.customTrueFalseText ?\n      this.data.customTrueFalseText[1] :\n      null;\n  }\n\n  get choices(): string[] | null {\n    return this.dialogType === DialogType.Choice ?\n      (this.data as DialogChoiceData).choices :\n      null;\n  }\n\n  close(): void {\n    let data: any;\n\n    switch (this.dialogType) {\n        case DialogType.Message:\n            data = this.data.checkboxMessage ?\n                {\n                    checkbox: this.checkboxValue || false\n                } :\n                null;\n            break;\n        case DialogType.Input:\n            data = this.data.checkboxMessage ?\n                {\n                    response: this.userInput,\n                    checkbox: this.checkboxValue || false\n                } :\n                this.userInput;\n            break;\n        case DialogType.Confirmation:\n            data = this.data.checkboxMessage ?\n                {\n                    response: true,\n                    checkbox: this.checkboxValue || false\n                } :\n                true;\n            break;\n    }\n\n    this.closed.emit(data);\n  }\n\n  cancel(): void {\n    let data: any;\n\n    if (this.dialogType === DialogType.Confirmation) {\n        data = this.data.checkboxMessage ?\n            {\n                response: false,\n                checkbox: this.checkboxValue || false\n            } :\n            false;\n    }\n\n    this.closed.emit(data);\n  }\n}\n","<h2 *ngIf=\"data?.title\" mat-dialog-title [innerHTML]=\"data.title\"></h2>\n\n<mat-dialog-content>\n    <div *ngIf=\"data?.message\" [innerHTML]=\"data.message\"></div>\n\n    <mat-form-field *ngIf=\"dialogType === DialogType.Input\">\n        <textarea matInput [placeholder]=\"data.placeholder ?? ''\" [(ngModel)]=\"userInput\"></textarea>\n    </mat-form-field>\n\n    <div id=\"checkbox\" *ngIf=\"data?.checkboxMessage\">\n        <mat-checkbox [(ngModel)]=\"checkboxValue\">\n            <span [innerHTML]=\"data.checkboxMessage\"></span>\n        </mat-checkbox>\n    </div>\n</mat-dialog-content>\n\n<mat-dialog-actions>\n    <ng-container *ngIf=\"dialogType !== DialogType.Choice\">\n        <button mat-raised-button (click)=\"close()\" [disabled]=\"dialogType === DialogType.Input && !userInput\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">Yes</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">True</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customTrueText }}</span>\n                <span *ngSwitchDefault>OK</span>\n            </span>\n        </button>\n        <button *ngIf=\"dialogType !== DialogType.Message\" mat-raised-button (click)=\"cancel()\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">No</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">False</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customFalseText }}</span>\n                <span *ngSwitchDefault>Cancel</span>\n            </span>\n        </button>\n    </ng-container>\n\n    <ng-container *ngIf=\"dialogType === DialogType.Choice\">\n        <button mat-raised-button *ngFor=\"let choice of choices; let i = index\" [matDialogClose]=\"i\">\n            <span>{{ choice }}</span>\n        </button>\n    </ng-container>\n</mat-dialog-actions>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.component.js","sourceRoot":"","sources":["../../../../../../../projects/cleavelandprice/ngx-lib/dialog/src/components/base/base.component.ts","../../../../../../../projects/cleavelandprice/ngx-lib/dialog/src/components/base/base.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAG9E,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;;;;;;;;;AAOrD,MAAM,OAAO,aAAa;IAL1B;QAME,8EAA8E;QAC9E,eAAU,GAAG,UAAU,CAAC;QACf,eAAU,GAAG,UAAU,CAAC,OAAO,CAAC;QAE/B,WAAM,GAAG,IAAI,YAAY,EAAO,CAAC;QAE3C,2BAAsB,GAAG,sBAAsB,CAAC;KAsEjD;IAhEC,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACpC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC;IACT,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACpC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC;IACT,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,UAAU,KAAK,UAAU,CAAC,MAAM,CAAC,CAAC;YAC3C,IAAI,CAAC,IAAyB,CAAC,OAAO,CAAC,CAAC;YACzC,IAAI,CAAC;IACT,CAAC;IAED,KAAK;QACH,IAAI,IAAS,CAAC;QAEd,QAAQ,IAAI,CAAC,UAAU,EAAE;YACrB,KAAK,UAAU,CAAC,OAAO;gBACnB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;oBAC9B;wBACI,QAAQ,EAAE,IAAI,CAAC,aAAa,IAAI,KAAK;qBACxC,CAAC,CAAC;oBACH,IAAI,CAAC;gBACT,MAAM;YACV,KAAK,UAAU,CAAC,KAAK;gBACjB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;oBAC9B;wBACI,QAAQ,EAAE,IAAI,CAAC,SAAS;wBACxB,QAAQ,EAAE,IAAI,CAAC,aAAa,IAAI,KAAK;qBACxC,CAAC,CAAC;oBACH,IAAI,CAAC,SAAS,CAAC;gBACnB,MAAM;YACV,KAAK,UAAU,CAAC,YAAY;gBACxB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;oBAC9B;wBACI,QAAQ,EAAE,IAAI;wBACd,QAAQ,EAAE,IAAI,CAAC,aAAa,IAAI,KAAK;qBACxC,CAAC,CAAC;oBACH,IAAI,CAAC;gBACT,MAAM;SACb;QAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAED,MAAM;QACJ,IAAI,IAAS,CAAC;QAEd,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,CAAC,YAAY,EAAE;YAC7C,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gBAC9B;oBACI,QAAQ,EAAE,KAAK;oBACf,QAAQ,EAAE,IAAI,CAAC,aAAa,IAAI,KAAK;iBACxC,CAAC,CAAC;gBACH,KAAK,CAAC;SACb;QAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;;0GA5EU,aAAa;8FAAb,aAAa,sICZ1B,69DAyCqB;2FD7BR,aAAa;kBALzB,SAAS;+BACE,aAAa;8BAOd,UAAU;sBAAlB,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACI,MAAM;sBAAf,MAAM","sourcesContent":["import { Component, Input, Output, EventEmitter } from '@angular/core';\r\n\r\nimport { ConfirmationDialogMode } from '../../model/confirmation-dialog-mode';\r\nimport { DialogBaseData } from '../../model/dialog-base-data';\r\nimport { DialogChoiceData } from '../../model/dialog-choice-data';\r\nimport { DialogType } from '../../model/dialog-type';\r\n\r\n@Component({\r\n  selector: 'dialog-base',\r\n  templateUrl: './base.component.html',\r\n  styleUrls: ['./base.component.css']\r\n})\r\nexport class BaseComponent {\r\n  // This is so that DialogType can be publish accessible from the HTML template\r\n  DialogType = DialogType;\r\n  @Input() dialogType = DialogType.Message;\r\n  @Input() data!: DialogBaseData;\r\n  @Output() closed = new EventEmitter<any>();\r\n\r\n  ConfirmationDialogMode = ConfirmationDialogMode;\r\n\r\n  // Form values\r\n  userInput!: string;\r\n  checkboxValue!: boolean;\r\n\r\n  get customTrueText(): string | null {\r\n    return this.data.customTrueFalseText ?\r\n      this.data.customTrueFalseText[0] :\r\n      null;\r\n  }\r\n\r\n  get customFalseText(): string | null {\r\n    return this.data.customTrueFalseText ?\r\n      this.data.customTrueFalseText[1] :\r\n      null;\r\n  }\r\n\r\n  get choices(): string[] | null {\r\n    return this.dialogType === DialogType.Choice ?\r\n      (this.data as DialogChoiceData).choices :\r\n      null;\r\n  }\r\n\r\n  close(): void {\r\n    let data: any;\r\n\r\n    switch (this.dialogType) {\r\n        case DialogType.Message:\r\n            data = this.data.checkboxMessage ?\r\n                {\r\n                    checkbox: this.checkboxValue || false\r\n                } :\r\n                null;\r\n            break;\r\n        case DialogType.Input:\r\n            data = this.data.checkboxMessage ?\r\n                {\r\n                    response: this.userInput,\r\n                    checkbox: this.checkboxValue || false\r\n                } :\r\n                this.userInput;\r\n            break;\r\n        case DialogType.Confirmation:\r\n            data = this.data.checkboxMessage ?\r\n                {\r\n                    response: true,\r\n                    checkbox: this.checkboxValue || false\r\n                } :\r\n                true;\r\n            break;\r\n    }\r\n\r\n    this.closed.emit(data);\r\n  }\r\n\r\n  cancel(): void {\r\n    let data: any;\r\n\r\n    if (this.dialogType === DialogType.Confirmation) {\r\n        data = this.data.checkboxMessage ?\r\n            {\r\n                response: false,\r\n                checkbox: this.checkboxValue || false\r\n            } :\r\n            false;\r\n    }\r\n\r\n    this.closed.emit(data);\r\n  }\r\n}\r\n","<h2 *ngIf=\"data?.title\" mat-dialog-title [innerHTML]=\"data.title\"></h2>\n\n<mat-dialog-content>\n    <div *ngIf=\"data?.message\" [innerHTML]=\"data.message\"></div>\n\n    <mat-form-field *ngIf=\"dialogType === DialogType.Input\">\n        <textarea matInput [placeholder]=\"data.placeholder ?? ''\" [(ngModel)]=\"userInput\"></textarea>\n    </mat-form-field>\n\n    <div id=\"checkbox\" *ngIf=\"data?.checkboxMessage\">\n        <mat-checkbox [(ngModel)]=\"checkboxValue\">\n            <span [innerHTML]=\"data.checkboxMessage\"></span>\n        </mat-checkbox>\n    </div>\n</mat-dialog-content>\n\n<mat-dialog-actions>\n    <ng-container *ngIf=\"dialogType !== DialogType.Choice\">\n        <button mat-raised-button (click)=\"close()\" [disabled]=\"dialogType === DialogType.Input && !userInput\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">Yes</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">True</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customTrueText }}</span>\n                <span *ngSwitchDefault>OK</span>\n            </span>\n        </button>\n        <button *ngIf=\"dialogType !== DialogType.Message\" mat-raised-button (click)=\"cancel()\">\n            <span [ngSwitch]=\"data.mode\">\n                <span *ngSwitchCase=\"ConfirmationDialogMode.YesNo\">No</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.TrueFalse\">False</span>\n                <span *ngSwitchCase=\"ConfirmationDialogMode.Custom\">{{ customFalseText }}</span>\n                <span *ngSwitchDefault>Cancel</span>\n            </span>\n        </button>\n    </ng-container>\n\n    <ng-container *ngIf=\"dialogType === DialogType.Choice\">\n        <button mat-raised-button *ngFor=\"let choice of choices; let i = index\" [matDialogClose]=\"i\">\n            <span>{{ choice }}</span>\n        </button>\n    </ng-container>\n</mat-dialog-actions>"]}

package/esm2020/dialog/components/choice/choice.component.mjs

@@ -11,13 +11,13 @@ export class ChoiceComponent {
         this.dialogType = DialogType.Choice;
     }
 }
-ChoiceComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ChoiceComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component });
-ChoiceComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: ChoiceComponent, selector: "dialog-choice", ngImport: i0, template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>", styles: [""], dependencies: [{ kind: "component", type: i2.BaseComponent, selector: "dialog-base", inputs: ["dialogType", "data"], outputs: ["closed"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ChoiceComponent, decorators: [{
+ChoiceComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: ChoiceComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component });
+ChoiceComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.1", type: ChoiceComponent, selector: "dialog-choice", ngImport: i0, template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>", styles: [""], dependencies: [{ kind: "component", type: i2.BaseComponent, selector: "dialog-base", inputs: ["dialogType", "data"], outputs: ["closed"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: ChoiceComponent, decorators: [{
             type: Component,
             args: [{ selector: 'dialog-choice', template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>" }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [MAT_DIALOG_DATA]
                 }] }, { type: i1.MatDialogRef }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hvaWNlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2RpYWxvZy9zcmMvY29tcG9uZW50cy9jaG9pY2UvY2hvaWNlLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2RpYWxvZy9zcmMvY29tcG9uZW50cy9jaG9pY2UvY2hvaWNlLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ2xELE9BQU8sRUFBZ0IsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHlCQUF5QixDQUFDOzs7O0FBT3JELE1BQU0sT0FBTyxlQUFlO0lBRzFCLFlBQTRDLElBQXNCLEVBQy9DLFNBQXdDO1FBRGYsU0FBSSxHQUFKLElBQUksQ0FBa0I7UUFDL0MsY0FBUyxHQUFULFNBQVMsQ0FBK0I7UUFIM0QsZUFBVSxHQUFHLFVBQVUsQ0FBQyxNQUFNLENBQUM7SUFJL0IsQ0FBQzs7NEdBTFUsZUFBZSxrQkFHTixlQUFlO2dHQUh4QixlQUFlLHFEQ1Y1Qix5SEFJYzsyRkRNRCxlQUFlO2tCQUwzQixTQUFTOytCQUNFLGVBQWU7OzBCQU9aLE1BQU07MkJBQUMsZUFBZSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNYXREaWFsb2dSZWYsIE1BVF9ESUFMT0dfREFUQSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2RpYWxvZyc7XG5pbXBvcnQgeyBEaWFsb2dDaG9pY2VEYXRhIH0gZnJvbSAnLi4vLi4vbW9kZWwvZGlhbG9nLWNob2ljZS1kYXRhJztcbmltcG9ydCB7IERpYWxvZ1R5cGUgfSBmcm9tICcuLi8uLi9tb2RlbC9kaWFsb2ctdHlwZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2RpYWxvZy1jaG9pY2UnLFxuICB0ZW1wbGF0ZVVybDogJy4vY2hvaWNlLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJy4vY2hvaWNlLmNvbXBvbmVudC5jc3MnXVxufSlcbmV4cG9ydCBjbGFzcyBDaG9pY2VDb21wb25lbnQge1xuICBkaWFsb2dUeXBlID0gRGlhbG9nVHlwZS5DaG9pY2U7XG5cbiAgY29uc3RydWN0b3IoQEluamVjdChNQVRfRElBTE9HX0RBVEEpIHB1YmxpYyBkYXRhOiBEaWFsb2dDaG9pY2VEYXRhLFxuICAgICAgICAgICAgICBwdWJsaWMgZGlhbG9nUmVmOiBNYXREaWFsb2dSZWY8Q2hvaWNlQ29tcG9uZW50Pikge1xuICB9XG59XG4iLCI8ZGlhbG9nLWJhc2VcbiAgW2RhdGFdPVwiZGF0YVwiXG4gIFtkaWFsb2dUeXBlXT1cImRpYWxvZ1R5cGVcIlxuICAoY2xvc2VkKT1cImRpYWxvZ1JlZi5jbG9zZSgkZXZlbnQpXCI+XG48L2RpYWxvZy1iYXNlPiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hvaWNlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2RpYWxvZy9zcmMvY29tcG9uZW50cy9jaG9pY2UvY2hvaWNlLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2RpYWxvZy9zcmMvY29tcG9uZW50cy9jaG9pY2UvY2hvaWNlLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ2xELE9BQU8sRUFBZ0IsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFHekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHlCQUF5QixDQUFDOzs7O0FBT3JELE1BQU0sT0FBTyxlQUFlO0lBRzFCLFlBQTRDLElBQXNCLEVBQy9DLFNBQXdDO1FBRGYsU0FBSSxHQUFKLElBQUksQ0FBa0I7UUFDL0MsY0FBUyxHQUFULFNBQVMsQ0FBK0I7UUFIM0QsZUFBVSxHQUFHLFVBQVUsQ0FBQyxNQUFNLENBQUM7SUFJL0IsQ0FBQzs7NEdBTFUsZUFBZSxrQkFHTixlQUFlO2dHQUh4QixlQUFlLHFEQ1g1Qix5SEFJYzsyRkRPRCxlQUFlO2tCQUwzQixTQUFTOytCQUNFLGVBQWU7OzBCQU9aLE1BQU07MkJBQUMsZUFBZSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IE1hdERpYWxvZ1JlZiwgTUFUX0RJQUxPR19EQVRBIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvZGlhbG9nJztcclxuXHJcbmltcG9ydCB7IERpYWxvZ0Nob2ljZURhdGEgfSBmcm9tICcuLi8uLi9tb2RlbC9kaWFsb2ctY2hvaWNlLWRhdGEnO1xyXG5pbXBvcnQgeyBEaWFsb2dUeXBlIH0gZnJvbSAnLi4vLi4vbW9kZWwvZGlhbG9nLXR5cGUnO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgc2VsZWN0b3I6ICdkaWFsb2ctY2hvaWNlJyxcclxuICB0ZW1wbGF0ZVVybDogJy4vY2hvaWNlLmNvbXBvbmVudC5odG1sJyxcclxuICBzdHlsZVVybHM6IFsnLi9jaG9pY2UuY29tcG9uZW50LmNzcyddXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDaG9pY2VDb21wb25lbnQge1xyXG4gIGRpYWxvZ1R5cGUgPSBEaWFsb2dUeXBlLkNob2ljZTtcclxuXHJcbiAgY29uc3RydWN0b3IoQEluamVjdChNQVRfRElBTE9HX0RBVEEpIHB1YmxpYyBkYXRhOiBEaWFsb2dDaG9pY2VEYXRhLFxyXG4gICAgICAgICAgICAgIHB1YmxpYyBkaWFsb2dSZWY6IE1hdERpYWxvZ1JlZjxDaG9pY2VDb21wb25lbnQ+KSB7XHJcbiAgfVxyXG59XHJcbiIsIjxkaWFsb2ctYmFzZVxuICBbZGF0YV09XCJkYXRhXCJcbiAgW2RpYWxvZ1R5cGVdPVwiZGlhbG9nVHlwZVwiXG4gIChjbG9zZWQpPVwiZGlhbG9nUmVmLmNsb3NlKCRldmVudClcIj5cbjwvZGlhbG9nLWJhc2U+Il19

package/esm2020/dialog/components/confirmation/confirmation.component.mjs

@@ -11,13 +11,13 @@ export class ConfirmationComponent {
         this.dialogType = DialogType.Confirmation;
     }
 }
-ConfirmationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ConfirmationComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component });
-ConfirmationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: ConfirmationComponent, selector: "dialog-confirmation", ngImport: i0, template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>", styles: [""], dependencies: [{ kind: "component", type: i2.BaseComponent, selector: "dialog-base", inputs: ["dialogType", "data"], outputs: ["closed"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ConfirmationComponent, decorators: [{
+ConfirmationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: ConfirmationComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component });
+ConfirmationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.1", type: ConfirmationComponent, selector: "dialog-confirmation", ngImport: i0, template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>", styles: [""], dependencies: [{ kind: "component", type: i2.BaseComponent, selector: "dialog-base", inputs: ["dialogType", "data"], outputs: ["closed"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: ConfirmationComponent, decorators: [{
             type: Component,
             args: [{ selector: 'dialog-confirmation', template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>" }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [MAT_DIALOG_DATA]
                 }] }, { type: i1.MatDialogRef }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dialog/components/input/input.component.mjs

@@ -11,13 +11,13 @@ export class InputComponent {
         this.dialogType = DialogType.Input;
     }
 }
-InputComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: InputComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component });
-InputComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: InputComponent, selector: "dialog-input", ngImport: i0, template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>", styles: [""], dependencies: [{ kind: "component", type: i2.BaseComponent, selector: "dialog-base", inputs: ["dialogType", "data"], outputs: ["closed"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: InputComponent, decorators: [{
+InputComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: InputComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component });
+InputComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.1", type: InputComponent, selector: "dialog-input", ngImport: i0, template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>", styles: [""], dependencies: [{ kind: "component", type: i2.BaseComponent, selector: "dialog-base", inputs: ["dialogType", "data"], outputs: ["closed"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: InputComponent, decorators: [{
             type: Component,
             args: [{ selector: 'dialog-input', template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>" }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [MAT_DIALOG_DATA]
                 }] }, { type: i1.MatDialogRef }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2xlYXZlbGFuZHByaWNlL25neC1saWIvZGlhbG9nL3NyYy9jb21wb25lbnRzL2lucHV0L2lucHV0LmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2RpYWxvZy9zcmMvY29tcG9uZW50cy9pbnB1dC9pbnB1dC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNsRCxPQUFPLEVBQWdCLGVBQWUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRXpFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQzs7OztBQU9yRCxNQUFNLE9BQU8sY0FBYztJQUd6QixZQUE0QyxJQUFvQixFQUM3QyxTQUF1QztRQURkLFNBQUksR0FBSixJQUFJLENBQWdCO1FBQzdDLGNBQVMsR0FBVCxTQUFTLENBQThCO1FBSDFELGVBQVUsR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDO0lBSTlCLENBQUM7OzJHQUxVLGNBQWMsa0JBR0wsZUFBZTsrRkFIeEIsY0FBYyxvRENWM0IseUhBSWM7MkZETUQsY0FBYztrQkFMMUIsU0FBUzsrQkFDRSxjQUFjOzswQkFPWCxNQUFNOzJCQUFDLGVBQWUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIEluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTWF0RGlhbG9nUmVmLCBNQVRfRElBTE9HX0RBVEEgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9kaWFsb2cnO1xuaW1wb3J0IHsgRGlhbG9nQmFzZURhdGEgfSBmcm9tICcuLi8uLi9tb2RlbC9kaWFsb2ctYmFzZS1kYXRhJztcbmltcG9ydCB7IERpYWxvZ1R5cGUgfSBmcm9tICcuLi8uLi9tb2RlbC9kaWFsb2ctdHlwZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2RpYWxvZy1pbnB1dCcsXG4gIHRlbXBsYXRlVXJsOiAnLi9pbnB1dC5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL2lucHV0LmNvbXBvbmVudC5jc3MnXVxufSlcbmV4cG9ydCBjbGFzcyBJbnB1dENvbXBvbmVudCB7XG4gIGRpYWxvZ1R5cGUgPSBEaWFsb2dUeXBlLklucHV0O1xuXG4gIGNvbnN0cnVjdG9yKEBJbmplY3QoTUFUX0RJQUxPR19EQVRBKSBwdWJsaWMgZGF0YTogRGlhbG9nQmFzZURhdGEsXG4gICAgICAgICAgICAgIHB1YmxpYyBkaWFsb2dSZWY6IE1hdERpYWxvZ1JlZjxJbnB1dENvbXBvbmVudD4pIHtcbiAgfVxufVxuIiwiPGRpYWxvZy1iYXNlXG4gIFtkYXRhXT1cImRhdGFcIlxuICBbZGlhbG9nVHlwZV09XCJkaWFsb2dUeXBlXCJcbiAgKGNsb3NlZCk9XCJkaWFsb2dSZWYuY2xvc2UoJGV2ZW50KVwiPlxuPC9kaWFsb2ctYmFzZT4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2xlYXZlbGFuZHByaWNlL25neC1saWIvZGlhbG9nL3NyYy9jb21wb25lbnRzL2lucHV0L2lucHV0LmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2RpYWxvZy9zcmMvY29tcG9uZW50cy9pbnB1dC9pbnB1dC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNsRCxPQUFPLEVBQWdCLGVBQWUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBR3pFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQzs7OztBQU9yRCxNQUFNLE9BQU8sY0FBYztJQUd6QixZQUE0QyxJQUFvQixFQUM3QyxTQUF1QztRQURkLFNBQUksR0FBSixJQUFJLENBQWdCO1FBQzdDLGNBQVMsR0FBVCxTQUFTLENBQThCO1FBSDFELGVBQVUsR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDO0lBSTlCLENBQUM7OzJHQUxVLGNBQWMsa0JBR0wsZUFBZTsrRkFIeEIsY0FBYyxvRENYM0IseUhBSWM7MkZET0QsY0FBYztrQkFMMUIsU0FBUzsrQkFDRSxjQUFjOzswQkFPWCxNQUFNOzJCQUFDLGVBQWUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIEluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBNYXREaWFsb2dSZWYsIE1BVF9ESUFMT0dfREFUQSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2RpYWxvZyc7XHJcblxyXG5pbXBvcnQgeyBEaWFsb2dCYXNlRGF0YSB9IGZyb20gJy4uLy4uL21vZGVsL2RpYWxvZy1iYXNlLWRhdGEnO1xyXG5pbXBvcnQgeyBEaWFsb2dUeXBlIH0gZnJvbSAnLi4vLi4vbW9kZWwvZGlhbG9nLXR5cGUnO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgc2VsZWN0b3I6ICdkaWFsb2ctaW5wdXQnLFxyXG4gIHRlbXBsYXRlVXJsOiAnLi9pbnB1dC5jb21wb25lbnQuaHRtbCcsXHJcbiAgc3R5bGVVcmxzOiBbJy4vaW5wdXQuY29tcG9uZW50LmNzcyddXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBJbnB1dENvbXBvbmVudCB7XHJcbiAgZGlhbG9nVHlwZSA9IERpYWxvZ1R5cGUuSW5wdXQ7XHJcblxyXG4gIGNvbnN0cnVjdG9yKEBJbmplY3QoTUFUX0RJQUxPR19EQVRBKSBwdWJsaWMgZGF0YTogRGlhbG9nQmFzZURhdGEsXHJcbiAgICAgICAgICAgICAgcHVibGljIGRpYWxvZ1JlZjogTWF0RGlhbG9nUmVmPElucHV0Q29tcG9uZW50Pikge1xyXG4gIH1cclxufVxyXG4iLCI8ZGlhbG9nLWJhc2VcbiAgW2RhdGFdPVwiZGF0YVwiXG4gIFtkaWFsb2dUeXBlXT1cImRpYWxvZ1R5cGVcIlxuICAoY2xvc2VkKT1cImRpYWxvZ1JlZi5jbG9zZSgkZXZlbnQpXCI+XG48L2RpYWxvZy1iYXNlPiJdfQ==

package/esm2020/dialog/components/message/message.component.mjs

@@ -11,13 +11,13 @@ export class MessageComponent {
         this.dialogType = DialogType.Message;
     }
 }
-MessageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: MessageComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component });
-MessageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: MessageComponent, selector: "dialog-message", ngImport: i0, template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>", styles: [""], dependencies: [{ kind: "component", type: i2.BaseComponent, selector: "dialog-base", inputs: ["dialogType", "data"], outputs: ["closed"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: MessageComponent, decorators: [{
+MessageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MessageComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component });
+MessageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.1", type: MessageComponent, selector: "dialog-message", ngImport: i0, template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>", styles: [""], dependencies: [{ kind: "component", type: i2.BaseComponent, selector: "dialog-base", inputs: ["dialogType", "data"], outputs: ["closed"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MessageComponent, decorators: [{
             type: Component,
             args: [{ selector: 'dialog-message', template: "<dialog-base\n  [data]=\"data\"\n  [dialogType]=\"dialogType\"\n  (closed)=\"dialogRef.close($event)\">\n</dialog-base>" }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [MAT_DIALOG_DATA]
                 }] }, { type: i1.MatDialogRef }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYi9kaWFsb2cvc3JjL2NvbXBvbmVudHMvbWVzc2FnZS9tZXNzYWdlLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL2RpYWxvZy9zcmMvY29tcG9uZW50cy9tZXNzYWdlL21lc3NhZ2UuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbEQsT0FBTyxFQUFnQixlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUV6RSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7Ozs7QUFPckQsTUFBTSxPQUFPLGdCQUFnQjtJQUczQixZQUE0QyxJQUFvQixFQUM3QyxTQUF5QztRQURoQixTQUFJLEdBQUosSUFBSSxDQUFnQjtRQUM3QyxjQUFTLEdBQVQsU0FBUyxDQUFnQztRQUg1RCxlQUFVLEdBQUcsVUFBVSxDQUFDLE9BQU8sQ0FBQztJQUloQyxDQUFDOzs2R0FMVSxnQkFBZ0Isa0JBR1AsZUFBZTtpR0FIeEIsZ0JBQWdCLHNEQ1Y3Qix5SEFJYzsyRkRNRCxnQkFBZ0I7a0JBTDVCLFNBQVM7K0JBQ0UsZ0JBQWdCOzswQkFPYixNQUFNOzJCQUFDLGVBQWUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIEluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTWF0RGlhbG9nUmVmLCBNQVRfRElBTE9HX0RBVEEgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9kaWFsb2cnO1xuaW1wb3J0IHsgRGlhbG9nQmFzZURhdGEgfSBmcm9tICcuLi8uLi9tb2RlbC9kaWFsb2ctYmFzZS1kYXRhJztcbmltcG9ydCB7IERpYWxvZ1R5cGUgfSBmcm9tICcuLi8uLi9tb2RlbC9kaWFsb2ctdHlwZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2RpYWxvZy1tZXNzYWdlJyxcbiAgdGVtcGxhdGVVcmw6ICcuL21lc3NhZ2UuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9tZXNzYWdlLmNvbXBvbmVudC5jc3MnXVxufSlcbmV4cG9ydCBjbGFzcyBNZXNzYWdlQ29tcG9uZW50IHtcbiAgZGlhbG9nVHlwZSA9IERpYWxvZ1R5cGUuTWVzc2FnZTtcblxuICBjb25zdHJ1Y3RvcihASW5qZWN0KE1BVF9ESUFMT0dfREFUQSkgcHVibGljIGRhdGE6IERpYWxvZ0Jhc2VEYXRhLFxuICAgICAgICAgICAgICBwdWJsaWMgZGlhbG9nUmVmOiBNYXREaWFsb2dSZWY8TWVzc2FnZUNvbXBvbmVudD4pIHtcbiAgfVxufVxuIiwiPGRpYWxvZy1iYXNlXG4gIFtkYXRhXT1cImRhdGFcIlxuICBbZGlhbG9nVHlwZV09XCJkaWFsb2dUeXBlXCJcbiAgKGNsb3NlZCk9XCJkaWFsb2dSZWYuY2xvc2UoJGV2ZW50KVwiPlxuPC9kaWFsb2ctYmFzZT4iXX0=
+//# sourceMappingURL=data:application/json;base64,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