@colijnit/corecomponents_v12 12.2.17 → 12.2.19

package/dist/corecomponents/esm2015/lib/components/base-input-date-picker/base-input-date-picker.directive.js

@@ -0,0 +1,25 @@
+import { Directive, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { BaseInputComponent } from "../base/base-input.component";
+import { CoreComponentsIcon } from "../../core/enum/core-components-icon.enum";
+export class BaseInputDatePickerDirective extends BaseInputComponent {
+    constructor() {
+        super(...arguments);
+        this.rightIcon = CoreComponentsIcon.CalendarDayRegular;
+        this.locale = 'en-EN';
+        this.leftIconClick = new EventEmitter();
+        this.closeAfterDateSelection = true;
+    }
+}
+BaseInputDatePickerDirective.decorators = [
+    { type: Directive }
+];
+BaseInputDatePickerDirective.propDecorators = {
+    parentForOverlay: [{ type: ViewChild, args: ["parentForOverlay", { read: ElementRef },] }],
+    locale: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    leftIcon: [{ type: Input }],
+    leftIconData: [{ type: Input }],
+    leftIconClick: [{ type: Output }],
+    closeAfterDateSelection: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/corecomponents/esm2015/lib/components/input-date-picker/input-date-picker.component.js

@@ -0,0 +1,91 @@
+import { Component, forwardRef, HostBinding, ViewEncapsulation } from '@angular/core';
+import { SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME } from '../../interfaces/screen-config-adapter-component-interface-name';
+import { OverlayService } from '../../service/overlay.service';
+import { BaseInputDatePickerDirective } from "../base-input-date-picker/base-input-date-picker.directive";
+import { CalendarComponent } from "../calendar/calendar.component";
+export class InputDatePickerComponent extends BaseInputDatePickerDirective {
+    showClass() {
+        return true;
+    }
+    handleDateSelected(date) {
+        this.setModel(date);
+        if (this.closeAfterDateSelection) {
+            this.toggleCalendar(false);
+        }
+    }
+    toggleCalendar(show) {
+        if (this.readonly) {
+            return;
+        }
+        this.showCalendar = show;
+        if (this.showCalendar) {
+            this._calendarComponentRef = this.overlayService.createComponent(CalendarComponent, {
+                parentForOverlay: this.parentForOverlay,
+                selectedDate: this.model
+            }, {
+                dateSelected: (event) => this.handleDateSelected(event),
+                clickedOutside: () => this.toggleCalendar(false)
+            });
+        }
+        else {
+            this.overlayService.removeComponent(this._calendarComponentRef);
+        }
+    }
+    handleDateChange(value) {
+        if (value) {
+            this.setModel(new Date(value));
+        }
+    }
+    modelSet() {
+        this.setModelAsString();
+    }
+    setModelAsString() {
+        if (this.model) {
+            const year = this.model.toLocaleString("default", { year: "numeric" });
+            const month = this.model.toLocaleString("default", { month: "2-digit" });
+            const day = this.model.toLocaleString("default", { day: "2-digit" });
+            this.modelAsString = `${year}-${month}-${day}`;
+        }
+        else {
+            this.modelAsString = null;
+        }
+    }
+    handleClearIconClicked() {
+        this.setModel(undefined);
+    }
+}
+InputDatePickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'co-input-date',
+                template: `
+      <co-input-text (clickOutside)="toggleCalendar(false)" overlayParent #parentForOverlay="overlayParent"
+                     [hidden]="hidden"
+                     [readonly]="readonly"
+                     [(model)]="modelAsString"
+                     [rightIcon]="rightIcon"
+                     [leftIcon]="leftIcon"
+                     [leftIconData]="leftIconData"
+                     [pattern]="'yyyy-MM-dd'"
+                     [type]="'date'"
+                     [placeholder]="placeholder"
+                     (leftIconClick)="leftIconClick.emit($event)"
+                     (rightIconClick)="toggleCalendar(true)"
+                     (blur)="handleDateChange(modelAsString)"
+                     (clearIconClick)="handleClearIconClicked()"
+      ></co-input-text>
+    `,
+                providers: [
+                    OverlayService, {
+                        provide: SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME, useExisting: forwardRef(() => InputDatePickerComponent)
+                    }, {
+                        provide: BaseInputDatePickerDirective,
+                        useExisting: InputDatePickerComponent
+                    }
+                ],
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+InputDatePickerComponent.propDecorators = {
+    showClass: [{ type: HostBinding, args: ['class.co-input-date',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/corecomponents/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/dist/corecomponents/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"]}

package/dist/corecomponents/esm2015/lib/components/simple-grid/base-simple-grid.component.js

@@ -0,0 +1,164 @@
+import { ContentChildren, Directive, EventEmitter, HostListener, Input, Output } from "@angular/core";
+import { SimpleGridColumnDirective } from "./simple-grid-column.directive";
+import { moveItemInArray } from "@angular/cdk/drag-drop";
+import { Subject } from "rxjs";
+export class BaseSimpleGridComponent {
+    constructor() {
+        this.MIN_COLUMN_WIDTH = 50;
+        this.dataChanged = new Subject();
+        this.dragDropEnabled = false;
+        this.resizable = false;
+        this.inlineEdit = false;
+        this.showEdit = false;
+        this.showToolbar = false;
+        this.autoAddRow = false;
+        /**
+         * Should component emit drag and drop actions instead of handle
+         * (update collection) by itself
+         */
+        this.emitDragDrop = false;
+        this.onDrop = new EventEmitter();
+        this.selectRow = new EventEmitter();
+        this.dblClickRow = new EventEmitter();
+        this.saveRow = new EventEmitter();
+        this.deleteRow = new EventEmitter();
+        this.addRow = new EventEmitter();
+        this.rowVisible = new EventEmitter();
+        this.columns = [];
+        this.headerColumns = [];
+        this._data = [];
+        this.disabledRows = [];
+        this._prepared = false;
+    }
+    set content(columnComponents) {
+        this._setColumns(columnComponents.toArray());
+        this._prepareData();
+    }
+    set data(value) {
+        this._data = value;
+        this._prepareData();
+        this.dataChanged.next();
+    }
+    get data() {
+        return this._data;
+    }
+    set extraColumns(value) {
+        this._setColumns(value);
+    }
+    handleMouseMove(event) {
+        if (this.resizable && event.buttons === 1 && this._columnForResize) {
+            // this._columnForResize.width = this._columnForResize.originalWidth - (this._startMousePositionX - event.clientX);
+        }
+    }
+    handleMouseUp(event) {
+        this._startMousePositionX = undefined;
+        this._columnForResize = undefined;
+    }
+    handleSizerMouseDown(event, column) {
+        this._setWidthOfAllColumns();
+        this._startMousePositionX = event.clientX;
+        this._columnForResize = column;
+        this._columnForResize.originalWidth = this._columnForResize.width;
+    }
+    handleCanDragDrop(drag, drop) {
+        return true;
+    }
+    handleDrop(event) {
+        try {
+            const from = event.previousIndex;
+            const to = event.currentIndex;
+            if (from === to) {
+                return;
+            }
+            if (this.emitDragDrop) {
+                this.onDrop.next({ from: from, to: to });
+            }
+            else {
+                moveItemInArray(this.data, from, to);
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    isSingleColumnRow(row) {
+        return row.hasOwnProperty('singleColumnIndex');
+    }
+    singleColumnIndex(row) {
+        return row.singleColumnIndex;
+    }
+    prepareDataRow(row, index) {
+    }
+    _setColumns(columns) {
+        this.columns.push(...columns);
+        this.columns.sort((a, b) => a.order < b.order ? -1 : 1);
+    }
+    _prepareData() {
+        if (this._prepared) {
+            return;
+        }
+        this.disabledRows.length = 0;
+        if (this.columns && this.columns.length > 0) {
+            this.headerColumns = this.columns.filter(c => !c.singleColumn);
+            let singleColumnIndex = -1;
+            for (let i = 0; i < this.columns.length; i++) {
+                if (this.columns[i].singleColumn) {
+                    singleColumnIndex = i;
+                    break;
+                }
+            }
+            // first check if there's single column data
+            if (singleColumnIndex > -1 && this.data && this.data.length > 0) {
+                const field = this.columns[singleColumnIndex].field;
+                for (let i = 0; i < this.data.length; i++) { // then mark row as single column row
+                    if (this.data[i][field] !== undefined && this.data[i][field] !== null && this.data[i][field] !== "") {
+                        // bit nasty to add prop, but cool for now
+                        this.data[i].singleColumnIndex = singleColumnIndex;
+                    }
+                    this.prepareDataRow(this.data[i], i);
+                }
+            }
+            this._prepared = true;
+        }
+        this._resizeColumnsToFit();
+    }
+    _resizeColumnsToFit() {
+        const calculateColumns = this.columns.filter(c => !c.autoFit && !c.width);
+        for (let i = 0; i < calculateColumns.length; i++) {
+            calculateColumns[i].width = `${100 / calculateColumns.length}%`;
+        }
+    }
+    _setWidthOfAllColumns() {
+        this.columns.forEach((column) => {
+            if ((column.width === undefined || column.width === null) && column.elementRef && column.elementRef.nativeElement) {
+                const rect = column.elementRef.nativeElement.getBoundingClientRect();
+                column.width = rect.width;
+            }
+        });
+    }
+}
+BaseSimpleGridComponent.decorators = [
+    { type: Directive }
+];
+BaseSimpleGridComponent.propDecorators = {
+    content: [{ type: ContentChildren, args: [SimpleGridColumnDirective,] }],
+    data: [{ type: Input }],
+    dragDropEnabled: [{ type: Input }],
+    resizable: [{ type: Input }],
+    inlineEdit: [{ type: Input }],
+    showEdit: [{ type: Input }],
+    showToolbar: [{ type: Input }],
+    autoAddRow: [{ type: Input }],
+    emitDragDrop: [{ type: Input }],
+    extraColumns: [{ type: Input }],
+    onDrop: [{ type: Output }],
+    selectRow: [{ type: Output }],
+    dblClickRow: [{ type: Output }],
+    saveRow: [{ type: Output }],
+    deleteRow: [{ type: Output }],
+    addRow: [{ type: Output }],
+    rowVisible: [{ type: Output }],
+    handleMouseMove: [{ type: HostListener, args: ['document:mousemove', ['$event'],] }],
+    handleMouseUp: [{ type: HostListener, args: ['document:mouseup', ['$event'],] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-simple-grid.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/simple-grid/base-simple-grid.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {ContentChildren, Directive, EventEmitter, HostListener, Input, Output, QueryList, ViewChildren} from \"@angular/core\";\r\nimport {SimpleGridColumnDirective} from \"./simple-grid-column.directive\";\r\nimport {CdkDrag, CdkDragDrop, CdkDropList, moveItemInArray} from \"@angular/cdk/drag-drop\";\r\nimport {Subject} from \"rxjs\";\r\n\r\n@Directive()\r\nexport abstract class BaseSimpleGridComponent {\r\n  public readonly MIN_COLUMN_WIDTH: number = 50;\r\n  public readonly dataChanged: Subject<void> = new Subject<void>();\r\n\r\n  @ContentChildren(SimpleGridColumnDirective) set content(columnComponents: QueryList<SimpleGridColumnDirective>) {\r\n    this._setColumns(columnComponents.toArray());\r\n    this._prepareData();\r\n  }\r\n\r\n  @Input()\r\n  public set data(value: Object[]) {\r\n    this._data = value;\r\n    this._prepareData();\r\n    this.dataChanged.next();\r\n  }\r\n\r\n  public get data(): Object[] {\r\n    return this._data;\r\n  }\r\n\r\n  @Input()\r\n  public dragDropEnabled: boolean = false;\r\n\r\n  @Input()\r\n  public resizable: boolean = false;\r\n\r\n  @Input()\r\n  public inlineEdit: boolean = false;\r\n\r\n  @Input()\r\n  public showEdit: boolean = false;\r\n\r\n  @Input()\r\n  public showToolbar: boolean = false;\r\n\r\n  @Input()\r\n  public autoAddRow: boolean = false;\r\n\r\n  /**\r\n   * Should component emit drag and drop actions instead of handle\r\n   * (update collection) by itself\r\n   */\r\n  @Input()\r\n  public emitDragDrop: boolean = false;\r\n\r\n  @Input()\r\n  public set extraColumns(value: SimpleGridColumnDirective[]) {\r\n    this._setColumns(value);\r\n  }\r\n\r\n  @Output()\r\n  public onDrop: EventEmitter<{from: number, to: number}> = new EventEmitter<{from: number; to: number}>();\r\n\r\n  @Output()\r\n  public selectRow: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @Output()\r\n  public dblClickRow: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @Output()\r\n  public saveRow: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @Output()\r\n  public deleteRow: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @Output()\r\n  public addRow: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @Output()\r\n  public rowVisible: EventEmitter<{}> = new EventEmitter<{}>();\r\n\r\n  @HostListener('document:mousemove', ['$event'])\r\n  public handleMouseMove(event: MouseEvent): void {\r\n    if (this.resizable && event.buttons === 1 && this._columnForResize) {\r\n      // this._columnForResize.width = this._columnForResize.originalWidth - (this._startMousePositionX - event.clientX);\r\n    }\r\n  }\r\n\r\n  @HostListener('document:mouseup', ['$event'])\r\n  public handleMouseUp(event: MouseEvent): void {\r\n    this._startMousePositionX = undefined;\r\n    this._columnForResize = undefined;\r\n  }\r\n\r\n  public columns: SimpleGridColumnDirective[] = [];\r\n  public headerColumns: SimpleGridColumnDirective[] = [];\r\n\r\n  protected _data: Object[] = [];\r\n  protected disabledRows: number[] = [];\r\n\r\n  private _columnForResize: SimpleGridColumnDirective;\r\n  private _prepared: boolean = false;\r\n  private _startMousePositionX: number;\r\n\r\n  public handleSizerMouseDown(event: MouseEvent, column: SimpleGridColumnDirective): void {\r\n    this._setWidthOfAllColumns();\r\n    this._startMousePositionX = event.clientX;\r\n    this._columnForResize = column;\r\n    this._columnForResize.originalWidth = this._columnForResize.width;\r\n  }\r\n\r\n  public handleCanDragDrop(drag: CdkDrag, drop: CdkDropList): boolean {\r\n    return true;\r\n  }\r\n\r\n  public handleDrop(event: CdkDragDrop<Object[]>): void {\r\n    try {\r\n      const from: number = event.previousIndex;\r\n      const to: number = event.currentIndex;\r\n      if (from === to) {\r\n        return;\r\n      }\r\n      if (this.emitDragDrop) {\r\n        this.onDrop.next({from: from, to: to});\r\n      } else {\r\n        moveItemInArray(this.data, from, to);\r\n      }\r\n    } catch (e) {\r\n      console.error(e);\r\n    }\r\n  }\r\n\r\n  public isSingleColumnRow(row: Object): boolean {\r\n    return row.hasOwnProperty('singleColumnIndex');\r\n  }\r\n\r\n  public singleColumnIndex(row: Object): number {\r\n    return (row as any).singleColumnIndex;\r\n  }\r\n\r\n  protected prepareDataRow(row: any, index: number): void {\r\n\r\n  }\r\n\r\n  private _setColumns(columns: SimpleGridColumnDirective[]): void {\r\n    this.columns.push(...columns);\r\n    this.columns.sort((a, b) => a.order < b.order ? -1 : 1);\r\n  }\r\n\r\n  private _prepareData(): void {\r\n    if (this._prepared) {\r\n      return;\r\n    }\r\n    this.disabledRows.length = 0;\r\n\r\n    if (this.columns && this.columns.length > 0) {\r\n      this.headerColumns = this.columns.filter(c => !c.singleColumn);\r\n      let singleColumnIndex: number = -1;\r\n      for (let i = 0; i < this.columns.length; i++) {\r\n        if (this.columns[i].singleColumn) {\r\n          singleColumnIndex = i;\r\n          break;\r\n        }\r\n      }\r\n      // first check if there's single column data\r\n      if (singleColumnIndex > -1 && this.data && this.data.length > 0) {\r\n        const field: string = this.columns[singleColumnIndex].field;\r\n        for (let i = 0; i < this.data.length; i++) { // then mark row as single column row\r\n          if (this.data[i][field] !== undefined && this.data[i][field] !== null && this.data[i][field] !== \"\") {\r\n            // bit nasty to add prop, but cool for now\r\n            (this.data[i] as any).singleColumnIndex = singleColumnIndex;\r\n          }\r\n          this.prepareDataRow(this.data[i], i);\r\n        }\r\n      }\r\n\r\n      this._prepared = true;\r\n    }\r\n    this._resizeColumnsToFit();\r\n  }\r\n\r\n  private _resizeColumnsToFit(): void {\r\n    const calculateColumns: SimpleGridColumnDirective[] = this.columns.filter(c => !c.autoFit && !c.width);\r\n    for (let i = 0; i < calculateColumns.length; i++) {\r\n      calculateColumns[i].width = `${100 / calculateColumns.length}%`;\r\n    }\r\n  }\r\n\r\n  private _setWidthOfAllColumns(): void {\r\n    this.columns.forEach((column: SimpleGridColumnDirective) => {\r\n      if ((column.width === undefined || column.width === null) && column.elementRef && column.elementRef.nativeElement) {\r\n        const rect: ClientRect = column.elementRef.nativeElement.getBoundingClientRect();\r\n        column.width = rect.width;\r\n      }\r\n    });\r\n  }\r\n\r\n}\r\n"]}