@colijnit/corecomponents_v12 12.2.25 → 12.2.26

package/esm2015/lib/components/popup/popup-buttons.component.js

@@ -0,0 +1,53 @@
+import { Component, EventEmitter, Input, Output, ViewChild } from "@angular/core";
+import { ButtonComponent } from "../button/button.component";
+import { PopupButtonGlobals } from "./model/popup-button-globals";
+// Component that is part of the WindowComponent, and represents the panel with buttons on the bottom of app popups.
+export class PopupButtonsComponent {
+    constructor() {
+        this.buttonClick = new EventEmitter();
+        this.buttons = [PopupButtonGlobals.Ok, PopupButtonGlobals.Cancel];
+    }
+    ngOnInit() {
+        if (!this.popupWindow || !this.popupWindow.settings) {
+            return;
+        }
+        if (this.popupWindow.settings.buttons) {
+            this.buttons = this.popupWindow.settings.buttons;
+        }
+    }
+    handleClick(event, button) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        event.stopPropagation();
+        this.buttonClick.emit(button);
+    }
+    focusFirstButton() {
+        if (this.firstButton) {
+            this.firstButton.focus();
+        }
+    }
+}
+PopupButtonsComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'co-popup-buttons',
+                template: `
+        <div class="popup-buttons">
+            <co-button
+                *ngFor="let button of buttons"
+                [label]="button.label"
+                [class]="button.cssClass"
+                [disabled]="button.disabled"
+                (click)="handleClick($event, button)"
+            ></co-button>
+        </div>
+    `,
+                styles: [":host{display:flex;justify-content:center}:host co-button:not(:last-child){margin-right:10px}:host .popup-buttons{display:flex}\n"]
+            },] }
+];
+PopupButtonsComponent.ctorParameters = () => [];
+PopupButtonsComponent.propDecorators = {
+    popupWindow: [{ type: Input }],
+    buttonClick: [{ type: Output }],
+    firstButton: [{ type: ViewChild, args: [ButtonComponent,] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/popup/popup-message-display.component.js

@@ -0,0 +1,47 @@
+import { __awaiter } from "tslib";
+import { Component, Input } from '@angular/core';
+import { FileUtils } from '../../core/utils/file-utils';
+import { BrowserUtils } from '../../core/utils/browser-utils';
+export class PopupMessageDisplayComponent {
+    constructor() {
+        this.image = false;
+        this._message = "";
+    }
+    set message(value) {
+        this._message = value;
+        this.image = FileUtils.StringContainsDataUri(value);
+    }
+    get message() {
+        return this._message;
+    }
+    // @implements AppPopup
+    onClose(eventType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return eventType;
+        });
+    }
+    handleCopyClick() {
+        BrowserUtils.CopyToClipboard(this.details);
+    }
+}
+PopupMessageDisplayComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-popup-message-display",
+                template: `
+        <span *ngIf="!image" class="message" [textContent]="message"></span>
+        <img *ngIf="image" [src]="message"/>
+        <ng-container *ngIf="details" label="DETAILS">
+            <div class="overflow-y-auto overflow-x-hidden details">
+                <span class="message wrap" [textContent]="details" style="overflow-wrap: break-word;"></span>
+            </div>
+            <span class="details-link" [textContent]="'COPY_MESSAGE_TO_CLIPBOARD'" (click)="handleCopyClick()"></span>
+        </ng-container>
+    `
+            },] }
+];
+PopupMessageDisplayComponent.ctorParameters = () => [];
+PopupMessageDisplayComponent.propDecorators = {
+    message: [{ type: Input }],
+    details: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/popup/popup-window-shell.component.js

@@ -0,0 +1,159 @@
+import { __awaiter } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, HostBinding, Input, ViewChild, ViewContainerRef } from "@angular/core";
+import { PopupButtonsComponent } from "./popup-buttons.component";
+import { PopupButtonType } from "../../core/enum/popup-button-type.enum";
+import { FileUtils } from "../../core/utils/file-utils";
+import { ObjectUtils } from "../../core/utils/object-utils";
+import { PopupType } from "../../core/enum/popup-type.enum";
+import { CoreComponentsIcon } from "../../core/enum/core-components-icon.enum";
+import { IconCacheService } from "../icon/icon-cache.service";
+// The main component for app popups. Visually represents the outer edges of the components.
+export class PopupWindowShellComponent {
+    constructor(_iconCache, _changeDetector, viewContainerRef) {
+        this._iconCache = _iconCache;
+        this._changeDetector = _changeDetector;
+        this.viewContainerRef = viewContainerRef;
+        this.icons = CoreComponentsIcon;
+        this._close = () => {
+            this.onCloseClick();
+        };
+    }
+    ngOnInit() {
+        this.closeIcon = this._iconCache.getIcon(this.icons.CrossSkinny);
+        this.downloadIcon = this._iconCache.getIcon(this.icons.Download);
+        this._setHostBindings();
+    }
+    ngAfterViewInit() {
+        this.popupWindow.popupWindowComponent = this;
+        this._createPopupComponent();
+        this._initOnClickAutoClose();
+        this._initAppPopupCloseRequestHandler();
+        if (!this.popupWindow.settings.noButtonFocus && this._appPopupButtons) {
+            setTimeout(() => {
+                this._appPopupButtons.focusFirstButton();
+            });
+        }
+        this._changeDetector.detectChanges();
+    }
+    ngOnDestroy() {
+        this._close();
+        this._viewContainer.clear();
+        this._popupCompRef = undefined;
+        this._viewContainer = undefined;
+        this._changeDetector = undefined;
+    }
+    close(eventType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._popupCompRef && this._popupCompRef.instance && this._popupCompRef.instance.onClose) {
+                const onCloseOutput = yield this._popupCompRef.instance.onClose(eventType);
+                this.popupWindow.onClose(eventType, onCloseOutput);
+            }
+            else {
+                this.popupWindow.onClose(eventType);
+            }
+        });
+    }
+    onButtonClick(button) {
+        if (!button.disabled) {
+            this.close(button.closeType);
+        }
+    }
+    onDownloadClick() {
+        try {
+            const dataUri = this._popupCompRef.instance.message;
+            FileUtils.DownloadFromDataUri(dataUri, FileUtils.CreateDownloadFileNameFromBase64(dataUri));
+        }
+        catch (e) {
+        }
+    }
+    onCloseClick() {
+        this.close(PopupButtonType.Cancel);
+    }
+    _createPopupComponent() {
+        this._popupCompRef = this._viewContainer.createComponent(this.popupWindow.factory);
+        ObjectUtils.ForOwnProperty(this.popupWindow.inputs, (value, key) => {
+            this._popupCompRef.instance[key] = value;
+        });
+        // give the concrete popup component access to its underlying model (with settings etc, e.g. for dynamic disabling/enabling of popup buttons on bottom)
+        this._popupCompRef.instance.popupModel = this.popupWindow;
+        if (this._popupCompRef.instance.onOpen) {
+            this._popupCompRef.instance.onOpen();
+        }
+    }
+    _initOnClickAutoClose() {
+        if (this.popupWindow && this.popupWindow.settings && this.popupWindow.settings.autoClose) {
+            if (this._filterClickSub) {
+                this._filterClickSub.unsubscribe();
+            }
+            // this._filterClickSub = this._filterService.onClick.subscribe(() => {
+            //     this.onCloseClick();
+            // });
+        }
+    }
+    _initAppPopupCloseRequestHandler() {
+        if (!this._popupCompRef || !this._popupCompRef.instance || !this._popupCompRef.instance.closeRequest) {
+            return;
+        }
+        if (this._popupCloseRequestSub) {
+            this._popupCloseRequestSub.unsubscribe();
+        }
+        this._popupCloseRequestSub = this._popupCompRef.instance.closeRequest.subscribe((closeButton) => {
+            if (!closeButton) {
+                closeButton = PopupButtonType.NoButton;
+            }
+            this.close(closeButton);
+        });
+    }
+    _setHostBindings() {
+        if (this.popupWindow) {
+            this.isError = this.popupWindow.type === PopupType.Error;
+            this.isWarning = this.popupWindow.type === PopupType.Warning;
+            this.isNotification = this.popupWindow.type === PopupType.Notification;
+            this.isQuestion = this.popupWindow.type === PopupType.Question;
+            this.isBlank = this.popupWindow.type === PopupType.Blank;
+            this.isMovable = !this.popupWindow.settings.fixed;
+        }
+    }
+}
+PopupWindowShellComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-popup-window-shell",
+                template: `
+    <ng-container *ngIf="!isBlank">
+      <co-button *ngIf="popupWindow?.settings.downloadable" class="circle shadowed popup-downloadable" [iconData]="downloadIcon"
+                 iconClass="light"
+                 (click)="onDownloadClick()"></co-button>
+      <co-button *ngIf="!popupWindow?.settings.hideCloseIcon" class="circle shadowed popup-close" [iconData]="closeIcon"
+                 iconClass="light"
+                 (click)="onCloseClick()"></co-button>
+      <div class="popup-wrapper" *ngIf="!isBlank">
+        <div class="popup-title"><h2 [textContent]="popupWindow?.settings.title"></h2></div>
+        <div class="popup-content" (mousedown)="$event.stopImmediatePropagation()">
+          <ng-template #popupContent></ng-template>
+        </div>
+        <co-popup-buttons [popupWindow]="popupWindow" (buttonClick)="onButtonClick($event)"></co-popup-buttons>
+      </div>
+    </ng-container>
+    <ng-template #popupContent *ngIf="isBlank"></ng-template>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [":host{position:fixed;display:flex;top:50%;left:50%;transform:translate(-50%,-50%)}:host.popup-error div.popup-wrapper{background:#CFD0D1}:host.popup-warning .secondary-font{color:#fff}:host.popup-warning div.popup-wrapper{background:#484F60}:host.popup-warning div.popup-title,:host.popup-warning div.popup-content{color:#fff}:host.popup-notification div.popup-wrapper,:host.popup-question div.popup-wrapper{background:#CFD0D1}co-button.popup-close,co-button.popup-downloadable{position:absolute;transform:translateY(-50%)}co-button.popup-close{right:5px}co-button.popup-downloadable{right:45px}.popup-wrapper{padding:30px;border-radius:5px;box-shadow:0 0 13px -2px #0003;background:#CFD0D1;min-width:320px}.popup-wrapper .popup-title{padding-bottom:20px;border-bottom:1px solid #DAD9D9}.popup-wrapper .popup-content{margin-top:20px;margin-bottom:20px;max-height:50vh;max-width:80vw;overflow:auto}\n"]
+            },] }
+];
+PopupWindowShellComponent.ctorParameters = () => [
+    { type: IconCacheService },
+    { type: ChangeDetectorRef },
+    { type: ViewContainerRef }
+];
+PopupWindowShellComponent.propDecorators = {
+    popupWindow: [{ type: Input }],
+    hasMobileSizings: [{ type: Input }, { type: HostBinding, args: ["class.mobile-sizings",] }],
+    _viewContainer: [{ type: ViewChild, args: ["popupContent", { read: ViewContainerRef },] }],
+    _appPopupButtons: [{ type: ViewChild, args: [PopupButtonsComponent,] }],
+    isError: [{ type: HostBinding, args: ["class.popup-error",] }],
+    isWarning: [{ type: HostBinding, args: ["class.popup-warning",] }],
+    isNotification: [{ type: HostBinding, args: ["class.popup-notification",] }],
+    isQuestion: [{ type: HostBinding, args: ["class.popup-question",] }],
+    isMovable: [{ type: HostBinding, args: ["class.movable",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popup-window-shell.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/popup/popup-window-shell.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterViewInit,\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ComponentRef,\r\n  HostBinding,\r\n  Inject,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  ViewChild,\r\n  ViewContainerRef\r\n} from \"@angular/core\";\r\nimport {PopupButtonsComponent} from \"./popup-buttons.component\";\r\nimport {Subscription} from \"rxjs\";\r\nimport {PopupButtonType} from \"../../core/enum/popup-button-type.enum\";\r\nimport {FileUtils} from \"../../core/utils/file-utils\";\r\nimport {ObjectUtils} from \"../../core/utils/object-utils\";\r\nimport {PopupType} from \"../../core/enum/popup-type.enum\";\r\nimport {PopupMessageDisplayComponent} from \"./popup-message-display.component\";\r\nimport {PopupWindowModel} from \"./model/popup-window\";\r\nimport {Popup} from \"./interface/popup\";\r\nimport {PopupButton} from \"./interface/popup-button\";\r\nimport {POPUP_WINDOW_DATA} from \"./const/popup-window-token\";\r\nimport {CoreComponentsIcon} from \"../../core/enum/core-components-icon.enum\";\r\nimport {IconCacheService} from \"../icon/icon-cache.service\";\r\nimport {SafeHtml} from \"@angular/platform-browser\";\r\n\r\n@Component({\r\n  selector: \"co-popup-window-shell\",\r\n  template: `\r\n    <ng-container *ngIf=\"!isBlank\">\r\n      <co-button *ngIf=\"popupWindow?.settings.downloadable\" class=\"circle shadowed popup-downloadable\" [iconData]=\"downloadIcon\"\r\n                 iconClass=\"light\"\r\n                 (click)=\"onDownloadClick()\"></co-button>\r\n      <co-button *ngIf=\"!popupWindow?.settings.hideCloseIcon\" class=\"circle shadowed popup-close\" [iconData]=\"closeIcon\"\r\n                 iconClass=\"light\"\r\n                 (click)=\"onCloseClick()\"></co-button>\r\n      <div class=\"popup-wrapper\" *ngIf=\"!isBlank\">\r\n        <div class=\"popup-title\"><h2 [textContent]=\"popupWindow?.settings.title\"></h2></div>\r\n        <div class=\"popup-content\" (mousedown)=\"$event.stopImmediatePropagation()\">\r\n          <ng-template #popupContent></ng-template>\r\n        </div>\r\n        <co-popup-buttons [popupWindow]=\"popupWindow\" (buttonClick)=\"onButtonClick($event)\"></co-popup-buttons>\r\n      </div>\r\n    </ng-container>\r\n    <ng-template #popupContent *ngIf=\"isBlank\"></ng-template>\r\n  `,\r\n  styleUrls: [\r\n    \"popup-window-shell.component.scss\"\r\n  ],\r\n  changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\n// The main component for app popups. Visually represents the outer edges of the components.\r\nexport class PopupWindowShellComponent implements AfterViewInit, OnDestroy, OnInit {\r\n\r\n  public readonly icons: typeof CoreComponentsIcon = CoreComponentsIcon;\r\n\r\n  @Input()\r\n  public popupWindow: PopupWindowModel;\r\n\r\n  @Input()\r\n  @HostBinding(\"class.mobile-sizings\")\r\n  public hasMobileSizings: boolean;\r\n\r\n  @ViewChild(\"popupContent\", {read: ViewContainerRef})\r\n  protected _viewContainer: ViewContainerRef;\r\n\r\n  @ViewChild(PopupButtonsComponent)\r\n  protected _appPopupButtons: PopupButtonsComponent;\r\n\r\n  @HostBinding(\"class.popup-error\")\r\n  public isError: boolean;\r\n\r\n  @HostBinding(\"class.popup-warning\")\r\n  public isWarning: boolean;\r\n\r\n  @HostBinding(\"class.popup-notification\")\r\n  public isNotification: boolean;\r\n\r\n  @HostBinding(\"class.popup-question\")\r\n  public isQuestion: boolean;\r\n\r\n  @HostBinding(\"class.movable\")\r\n  public isMovable: boolean;\r\n\r\n  public isBlank: boolean;\r\n\r\n  public closeIcon: SafeHtml;\r\n  public downloadIcon: SafeHtml;\r\n\r\n  // @HostBinding('style.top.px')\r\n  // public top: number = -1000; //start off-screen\r\n  //\r\n  // @HostBinding('style.left.px')\r\n  // public left: number = -1000; //start off-screen\r\n\r\n  private _popupCompRef: ComponentRef<Popup>;\r\n\r\n  private _filterClickSub: Subscription;\r\n\r\n  private _popupCloseRequestSub: Subscription;\r\n\r\n  constructor(\r\n    private _iconCache: IconCacheService,\r\n    private _changeDetector: ChangeDetectorRef,\r\n    public viewContainerRef: ViewContainerRef\r\n  ) {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.closeIcon = this._iconCache.getIcon(this.icons.CrossSkinny);\r\n    this.downloadIcon = this._iconCache.getIcon(this.icons.Download);\r\n    this._setHostBindings();\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    this.popupWindow.popupWindowComponent = this;\r\n    this._createPopupComponent();\r\n    this._initOnClickAutoClose();\r\n    this._initAppPopupCloseRequestHandler();\r\n\r\n    if (!this.popupWindow.settings.noButtonFocus && this._appPopupButtons) {\r\n      setTimeout(() => {\r\n        this._appPopupButtons.focusFirstButton();\r\n      });\r\n    }\r\n\r\n    this._changeDetector.detectChanges();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._close();\r\n    this._viewContainer.clear();\r\n    this._popupCompRef = undefined;\r\n    this._viewContainer = undefined;\r\n    this._changeDetector = undefined;\r\n  }\r\n\r\n  public async close(eventType: PopupButtonType): Promise<void> {\r\n    if (this._popupCompRef && this._popupCompRef.instance && this._popupCompRef.instance.onClose) {\r\n      const onCloseOutput: any = await this._popupCompRef.instance.onClose(eventType);\r\n      this.popupWindow.onClose(eventType, onCloseOutput);\r\n    } else {\r\n      this.popupWindow.onClose(eventType);\r\n    }\r\n  }\r\n\r\n  public onButtonClick(button: PopupButton): void {\r\n    if (!button.disabled) {\r\n      this.close(button.closeType);\r\n    }\r\n  }\r\n\r\n  public onDownloadClick(): void {\r\n    try {\r\n      const dataUri: string = (this._popupCompRef.instance as PopupMessageDisplayComponent).message;\r\n      FileUtils.DownloadFromDataUri(dataUri, FileUtils.CreateDownloadFileNameFromBase64(dataUri));\r\n    } catch (e) {\r\n\r\n    }\r\n  }\r\n\r\n  public onCloseClick(): void {\r\n    this.close(PopupButtonType.Cancel);\r\n  }\r\n\r\n  private _close = (): void => {\r\n    this.onCloseClick();\r\n  };\r\n\r\n  private _createPopupComponent(): void {\r\n    this._popupCompRef = this._viewContainer.createComponent(this.popupWindow.factory);\r\n    ObjectUtils.ForOwnProperty(this.popupWindow.inputs, (value: any, key: string) => {\r\n      this._popupCompRef.instance[key] = value;\r\n    });\r\n    // give the concrete popup component access to its underlying model (with settings etc, e.g. for dynamic disabling/enabling of popup buttons on bottom)\r\n    this._popupCompRef.instance.popupModel = this.popupWindow;\r\n    if (this._popupCompRef.instance.onOpen) {\r\n      this._popupCompRef.instance.onOpen();\r\n    }\r\n  }\r\n\r\n  private _initOnClickAutoClose(): void {\r\n    if (this.popupWindow && this.popupWindow.settings && this.popupWindow.settings.autoClose) {\r\n      if (this._filterClickSub) {\r\n        this._filterClickSub.unsubscribe();\r\n      }\r\n      // this._filterClickSub = this._filterService.onClick.subscribe(() => {\r\n      //     this.onCloseClick();\r\n      // });\r\n    }\r\n  }\r\n\r\n  private _initAppPopupCloseRequestHandler(): void {\r\n    if (!this._popupCompRef || !this._popupCompRef.instance || !this._popupCompRef.instance.closeRequest) {\r\n      return;\r\n    }\r\n\r\n    if (this._popupCloseRequestSub) {\r\n      this._popupCloseRequestSub.unsubscribe();\r\n    }\r\n    this._popupCloseRequestSub = this._popupCompRef.instance.closeRequest.subscribe((closeButton: PopupButtonType) => {\r\n      if (!closeButton) {\r\n        closeButton = PopupButtonType.NoButton;\r\n      }\r\n      this.close(closeButton);\r\n    });\r\n  }\r\n\r\n  private _setHostBindings(): void {\r\n    if (this.popupWindow) {\r\n      this.isError = this.popupWindow.type === PopupType.Error;\r\n      this.isWarning = this.popupWindow.type === PopupType.Warning;\r\n      this.isNotification = this.popupWindow.type === PopupType.Notification;\r\n      this.isQuestion = this.popupWindow.type === PopupType.Question;\r\n      this.isBlank = this.popupWindow.type === PopupType.Blank;\r\n      this.isMovable = !this.popupWindow.settings.fixed;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/popup/popup.module.js

@@ -0,0 +1,49 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { InputTextModule } from '../input-text/input-text.module';
+import { TextInputPopupComponent } from './text-input-popup.component';
+import { PopupMessageDisplayComponent } from './popup-message-display.component';
+import { PopupWindowShellComponent } from './popup-window-shell.component';
+import { PopupButtonsComponent } from './popup-buttons.component';
+import { ButtonModule } from '../button/button.module';
+import { PromptService } from './service/prompt.service';
+import { PopupShowerService } from './service/popup-shower.service';
+import { Overlay } from '@angular/cdk/overlay';
+import { IconCacheService } from '../icon/icon-cache.service';
+export class PopupModule {
+    static forRoot() {
+        return {
+            ngModule: PopupModule,
+            providers: [
+                PromptService,
+                PopupShowerService,
+                Overlay,
+                IconCacheService
+            ]
+        };
+    }
+}
+PopupModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    InputTextModule,
+                    ButtonModule
+                ],
+                declarations: [
+                    TextInputPopupComponent,
+                    PopupMessageDisplayComponent,
+                    PopupWindowShellComponent,
+                    PopupButtonsComponent
+                ],
+                entryComponents: [
+                    PopupMessageDisplayComponent,
+                    PopupWindowShellComponent
+                ],
+                exports: [
+                    TextInputPopupComponent,
+                    PopupWindowShellComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/popup/service/popup-shower.service.js

@@ -0,0 +1,90 @@
+import { __awaiter } from "tslib";
+import { ApplicationRef, ComponentFactoryResolver, Injectable, Injector } from "@angular/core";
+import { PopupWindowModel } from '../model/popup-window';
+import { PopupWindowShellComponent } from '../popup-window-shell.component';
+import { Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { POPUP_WINDOW_DATA } from '../const/popup-window-token';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+// Class responsible for showing popups throughout the application and returning results from user interaction with those popups.
+export class PopupShowerService {
+    constructor(_compFactoryResolver, _appRef, _overlay, _injector) {
+        this._compFactoryResolver = _compFactoryResolver;
+        this._appRef = _appRef;
+        this._overlay = _overlay;
+        this._injector = _injector;
+    }
+    showPopup(popupCompClazz, popupSettings, inputs = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const popupShellRef = this._createWindowShell();
+            const popupShell = popupShellRef.instance;
+            const config = this._getConfig();
+            const popupCompFactory = this._compFactoryResolver.resolveComponentFactory(popupCompClazz);
+            return new Promise((resolve) => {
+                const popupWindow = new PopupWindowModel(popupCompFactory, popupSettings, inputs);
+                // the generic onClose handler: remove the closed popup and resolve our original createPopup call with its output data
+                popupWindow.onClose = (eventType, output) => {
+                    this._appRef.detachView(popupShellRef.hostView);
+                    popupShellRef.destroy();
+                    resolve({
+                        eventType: eventType,
+                        output: output
+                    });
+                };
+                popupShell.popupWindow = popupWindow;
+            });
+        });
+    }
+    _createWindowShell() {
+        const componentRef = this._compFactoryResolver
+            .resolveComponentFactory(PopupWindowShellComponent)
+            .create(this._injector);
+        this._appRef.attachView(componentRef.hostView);
+        const domElem = componentRef.hostView.rootNodes[0];
+        document.body.appendChild(domElem);
+        return componentRef;
+    }
+    _createOverlay(config) {
+        return this._overlay.create(config);
+    }
+    _getConfig() {
+        const positionStrategy = this._overlay.position()
+            .global()
+            .centerHorizontally()
+            .centerVertically();
+        return new OverlayConfig({
+            hasBackdrop: true,
+            backdropClass: 'message-overlay-backdrop',
+            panelClass: 'message-overlay',
+            scrollStrategy: this._overlay.scrollStrategies.block(),
+            positionStrategy
+        });
+    }
+    _attachDialogContainer(overlayRef, popupWindow /*, dialogRef: FilePreviewOverlayRef*/) {
+        const injector = this._createInjector(popupWindow);
+        const containerPortal = new ComponentPortal(PopupWindowShellComponent, null, injector);
+        const containerRef = overlayRef.attach(containerPortal);
+        return containerRef.instance;
+    }
+    _createInjector(popupWindow) {
+        const injectionTokens = new WeakMap();
+        injectionTokens.set(POPUP_WINDOW_DATA, popupWindow);
+        const options = {
+            parent: this._injector,
+            providers: injectionTokens
+        };
+        return Injector.create(options);
+    }
+}
+PopupShowerService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PopupShowerService_Factory() { return new PopupShowerService(i0.ɵɵinject(i0.ComponentFactoryResolver), i0.ɵɵinject(i0.ApplicationRef), i0.ɵɵinject(i1.Overlay), i0.ɵɵinject(i0.INJECTOR)); }, token: PopupShowerService, providedIn: "root" });
+PopupShowerService.decorators = [
+    { type: Injectable, args: [{ providedIn: "root" },] }
+];
+PopupShowerService.ctorParameters = () => [
+    { type: ComponentFactoryResolver },
+    { type: ApplicationRef },
+    { type: Overlay },
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popup-shower.service.js","sourceRoot":"","sources":["../../../../../../../projects/corecomponents/src/lib/components/popup/service/popup-shower.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ApplicationRef,\r\n  ComponentFactory,\r\n  ComponentFactoryResolver,\r\n  ComponentRef,\r\n  EmbeddedViewRef,\r\n  Injectable,\r\n  Injector\r\n} from \"@angular/core\";\r\nimport { PopupSettings } from '../interface/popup-settings';\r\nimport { PopupCloseEvent } from '../interface/popup-close-event';\r\nimport { Popup } from '../interface/popup';\r\nimport { PopupWindowModel } from '../model/popup-window';\r\nimport { PopupWindowShellComponent } from '../popup-window-shell.component';\r\nimport { GlobalPositionStrategy, Overlay, OverlayConfig, OverlayRef } from '@angular/cdk/overlay';\r\nimport { ComponentPortal } from '@angular/cdk/portal';\r\nimport { POPUP_WINDOW_DATA } from '../const/popup-window-token';\r\nimport { PopupButtonType } from '../../../core/enum/popup-button-type.enum';\r\n\r\n// Class responsible for showing popups throughout the application and returning results from user interaction with those popups.\r\n@Injectable({providedIn: \"root\"})\r\nexport class PopupShowerService {\r\n\r\n    constructor(\r\n        private _compFactoryResolver: ComponentFactoryResolver,\r\n        private _appRef: ApplicationRef,\r\n        private _overlay: Overlay,\r\n        private _injector: Injector) {\r\n    }\r\n\r\n    public async showPopup<T = any>(popupCompClazz: any, popupSettings: PopupSettings, inputs: any = {}): Promise<PopupCloseEvent<T>> {\r\n        const popupShellRef: ComponentRef<PopupWindowShellComponent> = this._createWindowShell();\r\n        const popupShell: PopupWindowShellComponent = popupShellRef.instance;\r\n        const config: OverlayConfig = this._getConfig();\r\n        const popupCompFactory: ComponentFactory<Popup<T>> = this._compFactoryResolver.resolveComponentFactory(popupCompClazz);\r\n\r\n        return new Promise<PopupCloseEvent>((resolve: Function) => {\r\n\r\n          const popupWindow: PopupWindowModel = new PopupWindowModel(popupCompFactory, popupSettings, inputs);\r\n          // the generic onClose handler: remove the closed popup and resolve our original createPopup call with its output data\r\n          popupWindow.onClose = (eventType: PopupButtonType, output: any) => {\r\n            this._appRef.detachView(popupShellRef.hostView);\r\n            popupShellRef.destroy();\r\n            resolve({\r\n              eventType: eventType,\r\n              output: output\r\n            });\r\n          };\r\n          popupShell.popupWindow = popupWindow;\r\n        });\r\n    }\r\n\r\n    private _createWindowShell(): ComponentRef<PopupWindowShellComponent> {\r\n      const componentRef = this._compFactoryResolver\r\n        .resolveComponentFactory(PopupWindowShellComponent)\r\n        .create(this._injector);\r\n      this._appRef.attachView(componentRef.hostView);\r\n      const domElem = (componentRef.hostView as EmbeddedViewRef<any>).rootNodes[0] as HTMLElement;\r\n      document.body.appendChild(domElem);\r\n      return componentRef;\r\n    }\r\n\r\n    private _createOverlay(config: OverlayConfig): OverlayRef {\r\n        return this._overlay.create(config);\r\n    }\r\n\r\n    private _getConfig(): OverlayConfig {\r\n        const positionStrategy: GlobalPositionStrategy = this._overlay.position()\r\n            .global()\r\n            .centerHorizontally()\r\n            .centerVertically();\r\n\r\n        return new OverlayConfig({\r\n            hasBackdrop: true,\r\n            backdropClass: 'message-overlay-backdrop',\r\n            panelClass: 'message-overlay',\r\n            scrollStrategy: this._overlay.scrollStrategies.block(),\r\n            positionStrategy\r\n        });\r\n    }\r\n\r\n    private _attachDialogContainer(overlayRef: OverlayRef, popupWindow: PopupWindowModel /*, dialogRef: FilePreviewOverlayRef*/): PopupWindowShellComponent {\r\n        const injector: Injector = this._createInjector(popupWindow);\r\n        const containerPortal: ComponentPortal<PopupWindowShellComponent> = new ComponentPortal(PopupWindowShellComponent, null, injector);\r\n        const containerRef: ComponentRef<PopupWindowShellComponent> = overlayRef.attach(containerPortal);\r\n        return containerRef.instance;\r\n    }\r\n\r\n    private _createInjector(popupWindow: PopupWindowModel): Injector {\r\n        const injectionTokens: any = new WeakMap();\r\n        injectionTokens.set(POPUP_WINDOW_DATA, popupWindow);\r\n        const options = {\r\n          parent: this._injector,\r\n          providers: injectionTokens\r\n        };\r\n        return Injector.create(options);\r\n    }\r\n}\r\n"]}

package/esm2015/lib/components/popup/service/prompt.service.js

@@ -0,0 +1,127 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { PopupShowerService } from './popup-shower.service';
+import { PopupType } from '../../../core/enum/popup-type.enum';
+import { StringUtils } from '../../../core/utils/string-utils';
+import { PopupMessageDisplayComponent } from '../popup-message-display.component';
+import { PopupButtonType } from '../../../core/enum/popup-button-type.enum';
+import { StringPromptResultEvent } from '../../../core/model/event/string-prompt-result-event';
+import { TextInputPopupComponent } from '../text-input-popup.component';
+import { PopupButtonGlobals } from '../model/popup-button-globals';
+import { PopupSettings } from '../interface/popup-settings';
+import * as i0 from "@angular/core";
+import * as i1 from "./popup-shower.service";
+// Service responsible for delivering small popup windows (string input promps, alerts, etc.) to the user.
+export class PromptService {
+    constructor(_popupShower) {
+        this._popupShower = _popupShower;
+    }
+    // Spawns a text input popup with given title and initial text, and resolves the returned promise with the user-entered text as output.
+    promptString(title, label, initialText) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const popupSettings = new PopupSettings();
+            popupSettings.title = title;
+            const popupResult = yield this._popupShower.showPopup(TextInputPopupComponent, popupSettings, {
+                text: initialText,
+                label: label
+            });
+            return new StringPromptResultEvent(popupResult.eventType, popupResult.output);
+        });
+    }
+    // Shows given error text in an error popup to the user. Can also show an image instead of a text by supplying a data uri string.
+    showError(textOrImageDataUri, title, details) {
+        const popupSettings = new PopupSettings();
+        popupSettings.title = title || "ERROR";
+        popupSettings.type = PopupType.Error;
+        popupSettings.buttons = [PopupButtonGlobals.Ok];
+        return this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {
+            message: StringUtils.ToStringOrDefault(textOrImageDataUri),
+            details: details
+        });
+    }
+    // Shows given warning text in a warning popup to the user. Can also show an image instead of a text by supplying a data uri string.
+    showWarning(textOrImageDataUri, title) {
+        const popupSettings = new PopupSettings();
+        popupSettings.title = title || "WARNING";
+        popupSettings.type = PopupType.Warning;
+        popupSettings.buttons = [PopupButtonGlobals.Ok];
+        return this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {
+            message: StringUtils.ToStringOrDefault(textOrImageDataUri)
+        });
+    }
+    showNotification(textOrImageDataUri, title, showOk = true, autoClose = false, hideCloseIcon = false, downloadable = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const popupSettings = new PopupSettings();
+            popupSettings.title = title || "NOTIFICATION";
+            popupSettings.type = PopupType.Notification;
+            popupSettings.buttons = (showOk ? [PopupButtonGlobals.Ok] : []);
+            popupSettings.downloadable = downloadable;
+            if (autoClose) {
+                popupSettings.autoClose = true;
+            }
+            if (hideCloseIcon) {
+                popupSettings.hideCloseIcon = true;
+            }
+            const popupResult = yield this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, { message: StringUtils.ToStringOrDefault(textOrImageDataUri) });
+            return popupResult.eventType === PopupButtonType.Ok;
+        });
+    }
+    showImage(imageDataUri, title) {
+        return this.showNotification(imageDataUri, title, false, true, false, true);
+    }
+    showYesNo(textOrImageDataUri, title) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const popupSettings = new PopupSettings();
+            popupSettings.title = title || "QUESTION";
+            popupSettings.type = PopupType.Question;
+            popupSettings.buttons = [PopupButtonGlobals.Yes, PopupButtonGlobals.No];
+            const popupResult = yield this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {
+                message: StringUtils.ToStringOrDefault(textOrImageDataUri)
+            });
+            return popupResult.eventType === PopupButtonType.Yes;
+        });
+    }
+    // Spawns a modal 'yes, no or cancel' question prompt. Returns the chosen exit button through AppPopupCloseEvent.eventType.
+    showModalYesNoCancel(textOrImageDataUri, title) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const popupSettings = new PopupSettings();
+            popupSettings.title = title || "QUESTION";
+            popupSettings.type = PopupType.Question;
+            popupSettings.buttons = [PopupButtonGlobals.Yes, PopupButtonGlobals.No, PopupButtonGlobals.Cancel];
+            popupSettings.autoClose = false;
+            popupSettings.hideCloseIcon = true;
+            return this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {
+                message: StringUtils.ToStringOrDefault(textOrImageDataUri)
+            });
+        });
+    }
+    // Used by AS-copied code. We call it showNotification.
+    showOk(text, title) {
+        return this.showNotification(text, title);
+    }
+    showOkCancel(text, title) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const popupSettings = new PopupSettings();
+            popupSettings.title = title || "QUESTION";
+            popupSettings.type = PopupType.Question;
+            popupSettings.buttons = [PopupButtonGlobals.Ok, PopupButtonGlobals.Cancel];
+            popupSettings.autoClose = false;
+            popupSettings.hideCloseIcon = true;
+            const closeEvent = yield this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {
+                message: StringUtils.ToStringOrDefault(text)
+            });
+            return (closeEvent.eventType === PopupButtonType.Ok);
+        });
+    }
+    showOkModal(text, title) {
+        return this.showNotification(text, title, true, false, true);
+    }
+}
+PromptService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PromptService_Factory() { return new PromptService(i0.ɵɵinject(i1.PopupShowerService)); }, token: PromptService, providedIn: "root" });
+PromptService.decorators = [
+    { type: Injectable, args: [{ providedIn: "root" },] }
+];
+PromptService.ctorParameters = () => [
+    { type: PopupShowerService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prompt.service.js","sourceRoot":"","sources":["../../../../../../../projects/corecomponents/src/lib/components/popup/service/prompt.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { PopupShowerService } from './popup-shower.service';\r\nimport { PopupType } from '../../../core/enum/popup-type.enum';\r\nimport { StringUtils } from '../../../core/utils/string-utils';\r\nimport { PopupMessageDisplayComponent } from '../popup-message-display.component';\r\nimport { PopupButtonType } from '../../../core/enum/popup-button-type.enum';\r\nimport { StringPromptResultEvent } from '../../../core/model/event/string-prompt-result-event';\r\nimport { TextInputPopupComponent } from '../text-input-popup.component';\r\nimport { PopupButtonGlobals } from '../model/popup-button-globals';\r\nimport { PopupSettings } from '../interface/popup-settings';\r\nimport { PopupCloseEvent } from '../interface/popup-close-event';\r\n\r\n// Service responsible for delivering small popup windows (string input promps, alerts, etc.) to the user.\r\n@Injectable({providedIn: \"root\"})\r\nexport class PromptService {\r\n\r\n    constructor(private _popupShower: PopupShowerService) {\r\n    }\r\n\r\n    // Spawns a text input popup with given title and initial text, and resolves the returned promise with the user-entered text as output.\r\n    public async promptString(title: string, label?: string, initialText?: string): Promise<StringPromptResultEvent> {\r\n        const popupSettings: PopupSettings = new PopupSettings();\r\n        popupSettings.title = title;\r\n        const popupResult: PopupCloseEvent<string> = await this._popupShower.showPopup(TextInputPopupComponent, popupSettings, {\r\n            text: initialText,\r\n            label: label\r\n        });\r\n        return new StringPromptResultEvent(popupResult.eventType, popupResult.output);\r\n    }\r\n\r\n    // Shows given error text in an error popup to the user. Can also show an image instead of a text by supplying a data uri string.\r\n    public showError(textOrImageDataUri: string, title?: string, details?: string): Promise<PopupCloseEvent<void>> {\r\n        const popupSettings: PopupSettings = new PopupSettings();\r\n        popupSettings.title = title || \"ERROR\";\r\n        popupSettings.type = PopupType.Error;\r\n        popupSettings.buttons = [PopupButtonGlobals.Ok];\r\n        return this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {\r\n            message: StringUtils.ToStringOrDefault(textOrImageDataUri),\r\n            details: details\r\n        });\r\n    }\r\n\r\n    // Shows given warning text in a warning popup to the user. Can also show an image instead of a text by supplying a data uri string.\r\n    public showWarning(textOrImageDataUri: string, title?: string): Promise<PopupCloseEvent<void>> {\r\n        const popupSettings: PopupSettings = new PopupSettings();\r\n        popupSettings.title = title || \"WARNING\";\r\n        popupSettings.type = PopupType.Warning;\r\n        popupSettings.buttons = [PopupButtonGlobals.Ok];\r\n        return this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {\r\n            message: StringUtils.ToStringOrDefault(textOrImageDataUri)\r\n        });\r\n    }\r\n\r\n    public async showNotification(\r\n        textOrImageDataUri: string,\r\n        title?: string,\r\n        showOk: boolean = true,\r\n        autoClose: boolean = false,\r\n        hideCloseIcon: boolean = false,\r\n        downloadable: boolean = false\r\n    ): Promise<boolean> {\r\n        const popupSettings: PopupSettings = new PopupSettings();\r\n        popupSettings.title = title || \"NOTIFICATION\";\r\n        popupSettings.type = PopupType.Notification;\r\n        popupSettings.buttons = (showOk  ? [PopupButtonGlobals.Ok] : []);\r\n        popupSettings.downloadable = downloadable;\r\n        if (autoClose) {\r\n            popupSettings.autoClose = true;\r\n        }\r\n        if (hideCloseIcon) {\r\n            popupSettings.hideCloseIcon = true;\r\n        }\r\n        const popupResult: PopupCloseEvent<void> = await this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings,\r\n            {message: StringUtils.ToStringOrDefault(textOrImageDataUri)});\r\n        return popupResult.eventType === PopupButtonType.Ok;\r\n    }\r\n\r\n    public showImage(imageDataUri: string, title?: string): Promise<any> {\r\n        return this.showNotification(imageDataUri, title, false, true, false, true);\r\n    }\r\n\r\n    public async showYesNo(textOrImageDataUri: string, title?: string): Promise<boolean> {\r\n        const popupSettings: PopupSettings = new PopupSettings();\r\n        popupSettings.title = title || \"QUESTION\";\r\n        popupSettings.type = PopupType.Question;\r\n        popupSettings.buttons = [PopupButtonGlobals.Yes, PopupButtonGlobals.No];\r\n        const popupResult: any = await this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {\r\n            message: StringUtils.ToStringOrDefault(textOrImageDataUri)\r\n        });\r\n        return popupResult.eventType === PopupButtonType.Yes;\r\n    }\r\n\r\n    // Spawns a modal 'yes, no or cancel' question prompt. Returns the chosen exit button through AppPopupCloseEvent.eventType.\r\n    public async showModalYesNoCancel(textOrImageDataUri: string, title?: string): Promise<PopupCloseEvent<void>> {\r\n        const popupSettings: PopupSettings = new PopupSettings();\r\n        popupSettings.title = title || \"QUESTION\";\r\n        popupSettings.type = PopupType.Question;\r\n        popupSettings.buttons = [PopupButtonGlobals.Yes, PopupButtonGlobals.No, PopupButtonGlobals.Cancel];\r\n        popupSettings.autoClose = false;\r\n        popupSettings.hideCloseIcon = true;\r\n        return this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {\r\n            message: StringUtils.ToStringOrDefault(textOrImageDataUri)\r\n        });\r\n    }\r\n\r\n    // Used by AS-copied code. We call it showNotification.\r\n    public showOk(text: string, title?: string): Promise<boolean> {\r\n        return this.showNotification(text, title);\r\n    }\r\n\r\n    public async showOkCancel(text: string, title?: string): Promise<boolean> {\r\n        const popupSettings: PopupSettings = new PopupSettings();\r\n        popupSettings.title = title || \"QUESTION\";\r\n        popupSettings.type = PopupType.Question;\r\n        popupSettings.buttons = [PopupButtonGlobals.Ok, PopupButtonGlobals.Cancel];\r\n        popupSettings.autoClose = false;\r\n        popupSettings.hideCloseIcon = true;\r\n        const closeEvent: PopupCloseEvent =  await this._popupShower.showPopup(PopupMessageDisplayComponent, popupSettings, {\r\n            message: StringUtils.ToStringOrDefault(text)\r\n        });\r\n        return (closeEvent.eventType === PopupButtonType.Ok);\r\n    }\r\n\r\n    public showOkModal(text: string, title?: string): Promise<boolean> {\r\n        return this.showNotification(text, title, true, false, true);\r\n    }\r\n}\r\n"]}