turbogui-angular 13.0.0 → 13.0.2

package/esm2022/main/controller/dialog.service.mjs

@@ -216,68 +216,64 @@ export class DialogService {
     }
     /**
      * Show a dialog with one or more options that can be used to close it. We can use any of the predefined dialog types that are bundled with
-     * this library or extend DialogOptionsBaseComponent to create our own custom ones.
+     * this library or extend DialogBaseComponent to create our own custom ones.
      *
-     * @param width Specify the css value for the maximum width the dialog will have. As the dialog is responsive, the value will be automatically
-              reduced if the available screen is not enough, and will reach the desired value otherwise. Note that height will be adapted to the contents
-              of the dialog and cannot be specified here. We can set a pixels, % or any other css accepted value. For example: '400px', '50%', etc.
-     * @param texts A list with strings containing the dialog texts, sorted by importance. When dialog has a title, this should
-     *        be placed first, subtitle second and so (Each dialog may accept different number of texts).
-     * @param options A list of strings that will be used as button captions for each one of the accepted dialog options
-     * @param dialogComponentClass A class for a component that extends DialogOptionsBaseComponent, which will be the
-     *        dialog visual element that is shown to the user.
-     * @param callback A function that will be called after the dialog is closed and will receive an object with the numeric index and value for
-     *        the option that's been selected by the user. if no option was selected, the value will be -1
-     * @param modal True (default) if selecting an option is mandatory to close the dialog, false if the dialog can be closed
-     *        by the user by clicking outside it
-     * @param maxWidth Defines the maximum width that the dialog will have regarding the viewport. We can specify it in % or vw, just like is done in
-     *        css. By default it is defined as 96vw, which will fit 96% of the viewport on small devices
+     * @param dialogComponentClass A class for a component that extends DialogBaseComponent, which will be the dialog that is shown to the user.
+     * @param properties An object containing the different visual and textual options that this dialog allows:
+     *            - width: Specify the css value for the default dialog width. As the dialog is responsive, the value will be automatically
+     *              reduced if the available screen is not enough, and will reach the desired value otherwise. We can set any css unit like pixels,
+     *              %, vh, vw, or any other. For example: '400px', '50%', etc.
+     *            - maxWidth: Defines the maximum width that the dialog will have regarding the viewport. We can specify it in % or vw, just like is done in
+     *              css. By default it is defined as 96vw, which will fit 96% of the viewport on small devices
+     *            - height: TODO docs
+     *            - maxHeight: TODO docs
+     *            - modal: True (default) if selecting an option is mandatory to close the dialog, false if the dialog can be closed
+     *              by the user clicking outside it
+     *            - texts: A list with strings containing the dialog texts, sorted by importance. When dialog has a title, this should
+     *              be placed first, subtitle second and so (Each dialog may accept different number of texts).
+     *            - options: A list of strings that will be used as button captions for each one of the accepted dialog options
+     *
+     * @param callback A function that will be called after the dialog is closed and will receive a selection object with the numeric index and value for
+     *        the option that's been selected by the user. if no option was selected, index will be -1 and value null
      */
-    addDialog(dialogComponentClass, options, callback = null) {
+    addDialog(dialogComponentClass, properties, callback = null) {
         if (!this._isEnabled) {
             return;
         }
-        // Set the default values for all non specified visual options
-        options.width = options.hasOwnProperty('width') ? options.width : "50%";
-        options.maxWidth = options.hasOwnProperty('maxWidth') ? options.maxWidth : "96vw";
-        options.height = options.hasOwnProperty('height') ? options.height : "50%";
-        options.maxHeight = options.hasOwnProperty('maxHeight') ? options.maxHeight : "92vw";
-        options.modal = options.hasOwnProperty('modal') ? options.modal : true;
-        options.texts = options.hasOwnProperty('texts') ? options.texts : [];
-        options.captions = options.hasOwnProperty('captions') ? options.captions : [];
+        // Set the default values for non specified properties
+        properties.modal = properties.modal ?? true;
+        properties.texts = properties.texts ?? [];
+        properties.options = properties.options ?? [];
         // Generate a string to uniquely identify this dialog on the list of active dialogs
-        const dialogHash = options.texts.join('') + options.captions.join('') + dialogComponentClass.name;
+        const dialogHash = properties.texts.join('') + properties.options.join('') + dialogComponentClass.name;
         // identical dialogs won't be allowed at the same time
         if (this._activeDialogs.includes(dialogHash)) {
             return;
         }
         const dialogRef = this.matDialog.open(dialogComponentClass, {
-            width: options.width,
-            maxWidth: options.maxWidth,
-            disableClose: options.modal,
+            width: properties.width ?? "50%",
+            maxWidth: properties.maxWidth ?? "96vw",
+            disableClose: properties.modal,
             autoFocus: false,
-            closeOnNavigation: !options.modal,
-            data: { texts: options.texts, options: options.captions }
+            closeOnNavigation: !properties.modal,
+            data: { texts: properties.texts, options: properties.options }
         });
         this._activeDialogs.push(dialogHash);
         this._activeDialogInstances.push(dialogRef);
-        dialogRef.beforeClosed().subscribe((selectedOptionIndex) => {
+        dialogRef.beforeClosed().subscribe((selection) => {
             this._activeDialogs = ArrayUtils.removeElement(this._activeDialogs, dialogHash);
             this._activeDialogInstances = ArrayUtils.removeElement(this._activeDialogInstances, dialogRef);
-            if (!NumericUtils.isInteger(selectedOptionIndex)) {
-                if (options.modal) {
-                    throw new Error(`dialogRef.close() expects int value`);
-                }
-                else {
-                    selectedOptionIndex = -1;
-                }
+            if (!properties.modal && selection === undefined) {
+                selection = { index: -1 };
+            }
+            else if (!NumericUtils.isInteger(selection.index)) {
+                throw new Error(`closeDialog() expects index to be an integer`);
             }
             if (callback !== null) {
-                let selectedOption = { index: selectedOptionIndex, value: '' };
-                if (selectedOptionIndex >= 0) {
-                    selectedOption.value = options.captions[selectedOptionIndex];
+                if (selection.index >= 0 && selection.value === null) {
+                    selection.value = properties.options[selection.index];
                 }
-                callback(selectedOption);
+                callback(selection);
             }
         });
     }
@@ -291,29 +287,40 @@ export class DialogService {
             return;
         }
         for (const dialogRef of this._activeDialogInstances) {
-            dialogRef.close(-1);
+            dialogRef.close({ index: -1 });
         }
         this._activeDialogs = [];
         this._activeDialogInstances = [];
     }
-    addDateSelectionDialog(options, title, callback) {
+    /**
+     * Show a dialog with a calendar to let the user pick a date.
+     *
+     * @param properties An object containing the different visual and textual options that this dialog allows:
+     *            - width: Specify the css value for the default dialog width. As the dialog is responsive, the value will be automatically
+     *              reduced if the available screen is not enough, and will reach the desired value otherwise. We can set any css unit like pixels,
+     *              %, vh, vw, or any other. For example: '400px', '50%', etc.
+     *            - maxWidth: Defines the maximum width that the dialog will have regarding the viewport. We can specify it in % or vw, just like is done in
+     *              css. By default it is defined as 96vw, which will fit 96% of the viewport on small devices
+     *            - height: TODO docs
+     *            - maxHeight: TODO docs
+     *            - modal: True (default) if selecting an option is mandatory to close the dialog, false if the dialog can be closed
+     *              by the user clicking outside it
+     *            - title: An optional dialog title
+     * @param callback A function to be called after the dialog is closed. It will receive a Date() object selected by the user or null if no selection happened
+     */
+    addDateSelectionDialog(properties, callback) {
         if (!this._isEnabled) {
             return;
         }
         this.addDialog(DialogDateSelectionComponent, {
-            width: options.width,
-            maxWidth: options.maxWidth,
-            height: options.height,
-            maxHeight: options.maxHeight,
-            modal: options.modal,
-            texts: [title]
-        }, (selectedOption) => {
-            if (selectedOption.index < 0) {
-                callback(null);
-            }
-            else {
-                callback(selectedOption.value);
-            }
+            width: properties.width ?? "50%",
+            maxWidth: properties.maxWidth ?? "96vw",
+            height: properties.height ?? "50%",
+            maxHeight: properties.maxHeight ?? "92vw",
+            modal: properties.modal ?? false,
+            texts: [properties.title ?? '']
+        }, (selection) => {
+            callback(selection.index === -1 ? null : selection.value);
         });
     }
     /**
@@ -353,4 +360,4 @@ export class DialogService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: DialogService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i0.RendererFactory2 }, { type: i1.MatSnackBar }, { type: i2.MatDialog }, { type: i0.Injector }, { type: i0.ApplicationRef }, { type: i0.ComponentFactoryResolver }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../projects/turbogui-angular/src/main/controller/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * TurboGUI is A library that helps with the most common and generic UI elements and functionalities\r\n *\r\n * Website : -> http://www.turbogui.org\r\n * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.\r\n * License Url : -> http://www.apache.org/licenses/LICENSE-2.0\r\n * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com\r\n */\r\n\r\nimport { ArrayUtils, NumericUtils } from 'turbocommons-ts';\r\nimport { Type, Injectable, ComponentFactoryResolver, Injector, ApplicationRef, Renderer2, RendererFactory2 } from '@angular/core';\r\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { MatSnackBar, MatSnackBarConfig } from '@angular/material/snack-bar';\r\nimport { BusyStateBaseComponent } from '../view/components/busy-state-base/busy-state-base.component';\r\nimport { ComponentPortal, DomPortalOutlet } from '@angular/cdk/portal';\r\nimport { DialogOptionsBaseComponent } from '../view/components/dialog-options-base/dialog-options-base.component';\r\nimport { DialogBaseComponent } from '../view/components/dialog-base/dialog-base.component';\r\nimport { DialogDateSelectionComponent } from '../view/components/dialog-date-selection/dialog-date-selection.component';\n\r\n\r\n/**\r\n * Manages the application modal and non modal floating elements\r\n */\r\n@Injectable()\r\nexport class DialogService {\r\n\r\n\r\n    /**\r\n     * Used to modify the busy state component that is shown by default by the addModalBusyState() method.\r\n     *\r\n     * @see this.addModalBusyState()\r\n     */\r\n    customBusyStateComponentClass: Type<BusyStateBaseComponent> = BusyStateBaseComponent;\r\n\r\n\r\n    /**\r\n     * Check public getter for docs\r\n     */\r\n    private _isEnabled = true;\r\n\r\n\r\n    /**\r\n     * Tells if the main application is currently showing a busy state that blocks all user interaction\r\n     */\r\n    private _isShowingBusyState = false;\r\n\r\n\r\n    /**\r\n     * A reference to the modal busy state component that is initialized only the first time it is called.\r\n     *\r\n     * (To append the busy state dynamically, we use the Portal concept from the angular material library)\r\n     */\r\n    private _componentPortal: ComponentPortal<BusyStateBaseComponent> | null = null;\r\n\r\n\r\n    /**\r\n     * A reference to the modal busy state container where the component will be added\r\n     */\r\n    private _modalBusyStateHost: DomPortalOutlet | null = null;\r\n\r\n\r\n    /**\r\n     * Tells if the manager is currently showing a snackbar element or not\r\n     */\r\n    private _isShowingSnackBar = false;\r\n\r\n\r\n    /**\r\n     * Contains a list of the dialogs that are currently visible to the user.\r\n     * Each item in this list is a hash that is computed when dialog is created to uniquely identify it.\r\n     *\r\n     * Empty list means no dialogs are currently visible\r\n     */\r\n    private _activeDialogs: string[] = [];\r\n\r\n\r\n    /**\r\n     * Contains a list with all the MatDialog instances that are currently visible to the user.\r\n     * The list uses the same order as the list of _activeDialogs hash values\r\n     */\r\n    private _activeDialogInstances: MatDialogRef<DialogBaseComponent>[] = [];\r\n\r\n\r\n    /**\r\n     * Used to store the initialized Renderer 2 instance that is used by this class\r\n     */\r\n    private readonly _renderer: Renderer2;\r\n\r\n\r\n    /**\r\n     * Method that is used to delete the window beforeunload event listener once not used anymore\r\n     */\r\n    private _windowBeforeUnloadUnListen: (() => void) | null = null;\r\n\r\n\r\n    /**\r\n     * Method that is used to delete the document keydown event listener once not used anymore\r\n     */\r\n    private _documentKeydownUnlisten: (() => void) | null = null;\r\n\r\n\r\n    /**\r\n     * Method that is used to delete the document mousedown event listener once not used anymore\r\n     */\r\n    private _documentMousedownUnlisten: (() => void) | null = null;\r\n\r\n\r\n    /**\r\n     * Method that is used to delete the document pointerdown event listener once not used anymore\r\n     */\r\n    private _documentPointerdownUnlisten: (() => void) | null = null;\r\n\r\n\r\n    constructor(rendererFactory: RendererFactory2,\r\n                private readonly matSnackBar: MatSnackBar,\r\n                private readonly matDialog: MatDialog,\r\n                private readonly injector: Injector,\r\n                private readonly applicationRef: ApplicationRef,\r\n                private readonly componentFactoryResolver: ComponentFactoryResolver) {\r\n\r\n        this._renderer = rendererFactory.createRenderer(null, null);\r\n    }\r\n\r\n\r\n    /**\r\n     * Tells if this dialog service is enabled or not. If dialog service is disabled, none of it's features will work\r\n     * This is used to block all dialog features normally when shutting down the application\r\n     *\r\n     * Use with caution. When this is set to false, dialog service stops working.\r\n     */\r\n    set isEnabled(v: boolean) {\r\n\r\n        if (v === this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n\r\n        this._isEnabled = v;\r\n    }\r\n\r\n\r\n    /**\r\n     * Enables a warning that will be shown to the user when he/she tries to close the application.\r\n     * This warning will prompt the user to continue with the exit process or cancel it.\r\n     * The specific texts of this message are a generic ones and cannot be changed.\r\n     *\r\n     * IMPORTANT: This method must be called after the main application has been initialized in order to work,\r\n     * otherwise it will do nothing.\r\n     */\r\n    addCloseApplicationWarning() {\r\n\r\n        if (this._windowBeforeUnloadUnListen === null) {\r\n\r\n            this._windowBeforeUnloadUnListen = this._renderer.listen('window', 'beforeunload',\r\n                (event) => event.returnValue = true);\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Remove the close application warning message if previously assigned\r\n     */\r\n    removeCloseApplicationWarning() {\r\n\r\n        if (this._windowBeforeUnloadUnListen !== null) {\r\n\r\n            this._windowBeforeUnloadUnListen();\r\n            this._windowBeforeUnloadUnListen = null;\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Change the application visual appearance so the user perceives that the application is\r\n     * currently busy. While modal busy state is enabled, no user input is possible neither via\r\n     * keyboard, mouse or touch. Use this state when performing server requests or operations that\r\n     * must block the user interaction with the application.\r\n     *\r\n     * Note: We can modify the busy state component that is shown by this method. To do it, we must\r\n     * set this.customBusyStateComponentClass property with our own custom busy state component class. (We can do it at\r\n     * our main application component constructor for example). Our custom component must extend the\r\n     * BusyStateBaseComponent one to add its own visual appearance.\r\n     *\r\n     * @see this.customBusyStateComponentClass\r\n     */\r\n    addModalBusyState() {\r\n\r\n        if (!this._isEnabled || this._isShowingBusyState) {\r\n\r\n            return;\r\n        }\r\n\r\n        this._disableUserInteraction();\r\n\r\n        // Dynamically create the busy state component reference if this is the first time\r\n        if (this._componentPortal === null) {\r\n\r\n            this._componentPortal = new ComponentPortal(this.customBusyStateComponentClass);\r\n\r\n            // Create a PortalHost with document.body as its anchor element\r\n            this._modalBusyStateHost = new DomPortalOutlet(\r\n                    document.body,\r\n                    this.componentFactoryResolver,\r\n                    this.applicationRef,\r\n                    this.injector);\r\n        }\r\n\r\n        (this._modalBusyStateHost as DomPortalOutlet).attach(this._componentPortal);\r\n\r\n        this._isShowingBusyState = true;\r\n    }\r\n\r\n\r\n    /**\r\n     * Tells if the application is currently locked in a modal busy state (caused by an addModalBusyState() call)\r\n     */\r\n    get isShowingBusyState() {\r\n\r\n        return this._isShowingBusyState;\r\n    }\r\n\r\n\r\n    /**\r\n     * Remove the application busy state and restore it back to normal user interaction\r\n     */\r\n    removeModalBusyState() {\r\n\r\n        if (!this._isEnabled || !this._isShowingBusyState) {\r\n\r\n            return;\r\n        }\r\n\r\n        if (this._componentPortal !== null) {\r\n\r\n            (this._modalBusyStateHost as DomPortalOutlet).detach();\r\n        }\r\n\r\n        this._enableUserInteraction();\r\n\r\n        this._isShowingBusyState = false;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * TODO - adapt from TS version\r\n     */\r\n    addToolTip() {\r\n\r\n        // TODO - adapt from TS version\r\n    }\r\n\r\n\r\n    /**\r\n     * Show a non modal snackbar notification to the user (Only one snack-bar can ever be opened at the same time).\r\n     *\r\n     * Snackbars inform users of a process that an app has performed or will perform. They appear temporarily, towards the bottom or top of the screen.\r\n     * They shouldn’t interrupt the user experience, and they don’t require user input to disappear.\r\n     *\r\n     * @param config A MatSnackBarConfig instance with the customizations we want for this snackbar\r\n     * @param message The message to show on the snackbar\r\n     * @param action If not empty, the text to place on the snackbar confirmation button\r\n     * @param actionCallback A method to execute once the user clicks into the action button.\r\n     *\r\n     * @return void\r\n     */\r\n    addSnackBar(config: MatSnackBarConfig, message: string, action = '', actionCallback: (() => void) | null = null) {\r\n\r\n        if (!this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n\r\n        if (this._isShowingSnackBar) {\r\n\r\n            throw new Error('Trying to show a snackbar while another one is still visible');\r\n        }\r\n\r\n        this._isShowingSnackBar = true;\r\n\r\n        const snackBarRef = this.matSnackBar.open(message, action === '' ? undefined : action, config);\r\n\r\n        if (actionCallback !== null) {\r\n\r\n            snackBarRef.onAction().subscribe(() => {\r\n\r\n                actionCallback();\r\n            });\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Tells if the application is currently showing a snackbar or not\r\n     */\r\n    get isShowingSnackBar() {\r\n\r\n        return this._isShowingSnackBar;\r\n    }\r\n\r\n\r\n    /**\r\n     * Force the removal of the snack bar dialog if it exists.\r\n     *\r\n     * If no snackbar is currently visible, this method will do nothing\r\n     */\r\n    removeSnackBar() {\r\n\r\n        if (!this._isEnabled || !this._isShowingSnackBar) {\r\n\r\n            return;\r\n        }\r\n\r\n        this.matSnackBar.dismiss();\r\n\r\n        this._isShowingSnackBar = false;\r\n    }\r\n\r\n\r\n    /**\r\n     * Show a dialog with one or more options that can be used to close it. We can use any of the predefined dialog types that are bundled with\r\n     * this library or extend DialogOptionsBaseComponent to create our own custom ones.\r\n     *\r\n     * @param width Specify the css value for the maximum width the dialog will have. As the dialog is responsive, the value will be automatically\r\n              reduced if the available screen is not enough, and will reach the desired value otherwise. Note that height will be adapted to the contents\r\n              of the dialog and cannot be specified here. We can set a pixels, % or any other css accepted value. For example: '400px', '50%', etc.\r\n     * @param texts A list with strings containing the dialog texts, sorted by importance. When dialog has a title, this should\r\n     *        be placed first, subtitle second and so (Each dialog may accept different number of texts).\r\n     * @param options A list of strings that will be used as button captions for each one of the accepted dialog options\r\n     * @param dialogComponentClass A class for a component that extends DialogOptionsBaseComponent, which will be the\r\n     *        dialog visual element that is shown to the user.\r\n     * @param callback A function that will be called after the dialog is closed and will receive an object with the numeric index and value for\r\n     *        the option that's been selected by the user. if no option was selected, the value will be -1\r\n     * @param modal True (default) if selecting an option is mandatory to close the dialog, false if the dialog can be closed\r\n     *        by the user by clicking outside it \r\n     * @param maxWidth Defines the maximum width that the dialog will have regarding the viewport. We can specify it in % or vw, just like is done in\r\n     *        css. By default it is defined as 96vw, which will fit 96% of the viewport on small devices\r\n     */\r\n    addDialog(dialogComponentClass: Type<DialogOptionsBaseComponent>,\r\n              options: {width?: string,\r\n                        maxWidth?: string,\r\n                        height?: string,\r\n                        maxHeight?: string,\r\n                        modal?: boolean,\r\n                        texts?: string[],\r\n                        captions?: string[]}, \r\n              callback: null | ((selectedOption: {index:number, value: any}) => void) = null) {\r\n\r\n        if (!this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n        \r\n        // Set the default values for all non specified visual options\r\n        options.width = options.hasOwnProperty('width') ? options.width : \"50%\";\r\n        options.maxWidth = options.hasOwnProperty('maxWidth') ? options.maxWidth : \"96vw\";\r\n        options.height = options.hasOwnProperty('height') ? options.height : \"50%\";\r\n        options.maxHeight = options.hasOwnProperty('maxHeight') ? options.maxHeight : \"92vw\";\r\n        options.modal = options.hasOwnProperty('modal') ? options.modal : true;\r\n        options.texts = options.hasOwnProperty('texts') ? options.texts : [];\r\n        options.captions = options.hasOwnProperty('captions') ? options.captions : [];\r\n\r\n        // Generate a string to uniquely identify this dialog on the list of active dialogs\r\n        const dialogHash = options.texts!.join('') + options.captions!.join('') + dialogComponentClass.name;\r\n\r\n        // identical dialogs won't be allowed at the same time\r\n        if (this._activeDialogs.includes(dialogHash)) {\r\n\r\n            return;\r\n        }\r\n\r\n        const dialogRef = this.matDialog.open(dialogComponentClass, {\r\n            width: options.width,\r\n            maxWidth: options.maxWidth,\r\n            disableClose: options.modal,\r\n            autoFocus: false,\r\n            closeOnNavigation: !options.modal,\r\n            data: { texts: options.texts, options: options.captions }\r\n          });\r\n\r\n        this._activeDialogs.push(dialogHash);\r\n        this._activeDialogInstances.push(dialogRef);\r\n\r\n        dialogRef.beforeClosed().subscribe((selectedOptionIndex: any) => {\r\n\r\n            this._activeDialogs = ArrayUtils.removeElement(this._activeDialogs, dialogHash);\r\n            this._activeDialogInstances = ArrayUtils.removeElement(this._activeDialogInstances, dialogRef);\r\n\r\n            if (!NumericUtils.isInteger(selectedOptionIndex)) {\r\n\r\n                if(options.modal){\r\n                    \r\n                    throw new Error(`dialogRef.close() expects int value`);\r\n\r\n                }else{\r\n                    \r\n                    selectedOptionIndex = -1;\r\n                }                \r\n            }\r\n\r\n            if (callback !== null) {\r\n\r\n                let selectedOption = {index: selectedOptionIndex, value: ''};\r\n                \r\n                if(selectedOptionIndex >= 0){\r\n                    \r\n                    selectedOption.value = options.captions![selectedOptionIndex];\r\n                }\r\n\r\n                (callback as ((selectedOption: {index:number, value: string}) => void))(selectedOption);\r\n            }\r\n        });\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Force the removal of all the dialogs that are currently visible.\r\n     *\r\n     * If no dialogs are currently visible, this method will do nothing\r\n     */\r\n    removeAllDialogs() {\r\n\r\n        if (!this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n\r\n        for (const dialogRef of this._activeDialogInstances) {\r\n\r\n            dialogRef.close(-1);\r\n        }\r\n        \r\n        this._activeDialogs = [];\r\n        this._activeDialogInstances = [];\r\n    }\r\n    \r\n    \r\n    addDateSelectionDialog(options: {width?: string,\r\n                                     maxWidth?: string,\r\n                                     height?: string,\r\n                                     maxHeight?: string,\r\n                                     modal?: boolean},\r\n                           title: string,\r\n                           callback: ((selectedDate: null | Date) => void)) {\r\n\r\n        if (!this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n        \r\n        this.addDialog(DialogDateSelectionComponent,\r\n            {\r\n                width: options.width,\r\n                maxWidth: options.maxWidth,\r\n                height: options.height,\r\n                maxHeight: options.maxHeight,\r\n                modal: options.modal,\r\n                texts: [title]   \r\n            },(selectedOption) => {\r\n            \r\n                if(selectedOption.index < 0){\r\n                    \r\n                    callback(null);\r\n                \r\n                }else{\r\n                    \r\n                    callback(selectedOption.value);\r\n                }  \r\n            });\r\n    }\r\n\r\n\r\n    /**\r\n     * Block all the user interactions with the application (keyboard, touch, mouse, ...)\r\n     */\r\n    private _disableUserInteraction() {\r\n\r\n        if (this._documentKeydownUnlisten === null) {\r\n\r\n            this._documentKeydownUnlisten = this._renderer.listen('document', 'keydown', (event) => event.preventDefault());\r\n        }\r\n\r\n        if (this._documentMousedownUnlisten === null) {\r\n\r\n            this._documentMousedownUnlisten = this._renderer.listen('document', 'mousedown', (event) => event.preventDefault());\r\n        }\r\n\r\n        if (this._documentPointerdownUnlisten === null) {\r\n\r\n            this._documentPointerdownUnlisten = this._renderer.listen('document', 'pointerdown', (event) => event.preventDefault());\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Restore the user interactions that were previously disabled with _disableUserInteraction method\r\n     */\r\n    private _enableUserInteraction() {\r\n\r\n        if (this._documentKeydownUnlisten !== null) {\r\n\r\n            this._documentKeydownUnlisten();\r\n            this._documentKeydownUnlisten = null;\r\n        }\r\n\r\n        if (this._documentMousedownUnlisten !== null) {\r\n\r\n            this._documentMousedownUnlisten();\r\n            this._documentMousedownUnlisten = null;\r\n        }\r\n\r\n        if (this._documentPointerdownUnlisten !== null) {\r\n\r\n            this._documentPointerdownUnlisten();\r\n            this._documentMousedownUnlisten = null;\r\n        }\r\n    }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../projects/turbogui-angular/src/main/controller/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * TurboGUI is A library that helps with the most common and generic UI elements and functionalities\r\n *\r\n * Website : -> http://www.turbogui.org\r\n * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.\r\n * License Url : -> http://www.apache.org/licenses/LICENSE-2.0\r\n * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com\r\n */\r\n\r\nimport { ArrayUtils, NumericUtils } from 'turbocommons-ts';\r\nimport { Type, Injectable, ComponentFactoryResolver, Injector, ApplicationRef, Renderer2, RendererFactory2 } from '@angular/core';\r\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { MatSnackBar, MatSnackBarConfig } from '@angular/material/snack-bar';\r\nimport { BusyStateBaseComponent } from '../view/components/busy-state-base/busy-state-base.component';\r\nimport { ComponentPortal, DomPortalOutlet } from '@angular/cdk/portal';\r\nimport { DialogBaseComponent } from '../view/components/dialog-base/dialog-base.component';\r\nimport { DialogDateSelectionComponent } from '../view/components/dialog-date-selection/dialog-date-selection.component';\n\r\n\r\n/**\r\n * Manages the application modal and non modal floating elements\r\n */\r\n@Injectable()\r\nexport class DialogService {\r\n\r\n\r\n    /**\r\n     * Used to modify the busy state component that is shown by default by the addModalBusyState() method.\r\n     *\r\n     * @see this.addModalBusyState()\r\n     */\r\n    customBusyStateComponentClass: Type<BusyStateBaseComponent> = BusyStateBaseComponent;\r\n\r\n\r\n    /**\r\n     * Check public getter for docs\r\n     */\r\n    private _isEnabled = true;\r\n\r\n\r\n    /**\r\n     * Tells if the main application is currently showing a busy state that blocks all user interaction\r\n     */\r\n    private _isShowingBusyState = false;\r\n\r\n\r\n    /**\r\n     * A reference to the modal busy state component that is initialized only the first time it is called.\r\n     *\r\n     * (To append the busy state dynamically, we use the Portal concept from the angular material library)\r\n     */\r\n    private _componentPortal: ComponentPortal<BusyStateBaseComponent> | null = null;\r\n\r\n\r\n    /**\r\n     * A reference to the modal busy state container where the component will be added\r\n     */\r\n    private _modalBusyStateHost: DomPortalOutlet | null = null;\r\n\r\n\r\n    /**\r\n     * Tells if the manager is currently showing a snackbar element or not\r\n     */\r\n    private _isShowingSnackBar = false;\r\n\r\n\r\n    /**\r\n     * Contains a list of the dialogs that are currently visible to the user.\r\n     * Each item in this list is a hash that is computed when dialog is created to uniquely identify it.\r\n     *\r\n     * Empty list means no dialogs are currently visible\r\n     */\r\n    private _activeDialogs: string[] = [];\r\n\r\n\r\n    /**\r\n     * Contains a list with all the MatDialog instances that are currently visible to the user.\r\n     * The list uses the same order as the list of _activeDialogs hash values\r\n     */\r\n    private _activeDialogInstances: MatDialogRef<DialogBaseComponent>[] = [];\r\n\r\n\r\n    /**\r\n     * Used to store the initialized Renderer 2 instance that is used by this class\r\n     */\r\n    private readonly _renderer: Renderer2;\r\n\r\n\r\n    /**\r\n     * Method that is used to delete the window beforeunload event listener once not used anymore\r\n     */\r\n    private _windowBeforeUnloadUnListen: (() => void) | null = null;\r\n\r\n\r\n    /**\r\n     * Method that is used to delete the document keydown event listener once not used anymore\r\n     */\r\n    private _documentKeydownUnlisten: (() => void) | null = null;\r\n\r\n\r\n    /**\r\n     * Method that is used to delete the document mousedown event listener once not used anymore\r\n     */\r\n    private _documentMousedownUnlisten: (() => void) | null = null;\r\n\r\n\r\n    /**\r\n     * Method that is used to delete the document pointerdown event listener once not used anymore\r\n     */\r\n    private _documentPointerdownUnlisten: (() => void) | null = null;\r\n\r\n\r\n    constructor(rendererFactory: RendererFactory2,\r\n                private readonly matSnackBar: MatSnackBar,\r\n                private readonly matDialog: MatDialog,\r\n                private readonly injector: Injector,\r\n                private readonly applicationRef: ApplicationRef,\r\n                private readonly componentFactoryResolver: ComponentFactoryResolver) {\r\n\r\n        this._renderer = rendererFactory.createRenderer(null, null);\r\n    }\r\n\r\n\r\n    /**\r\n     * Tells if this dialog service is enabled or not. If dialog service is disabled, none of it's features will work\r\n     * This is used to block all dialog features normally when shutting down the application\r\n     *\r\n     * Use with caution. When this is set to false, dialog service stops working.\r\n     */\r\n    set isEnabled(v: boolean) {\r\n\r\n        if (v === this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n\r\n        this._isEnabled = v;\r\n    }\r\n\r\n\r\n    /**\r\n     * Enables a warning that will be shown to the user when he/she tries to close the application.\r\n     * This warning will prompt the user to continue with the exit process or cancel it.\r\n     * The specific texts of this message are a generic ones and cannot be changed.\r\n     *\r\n     * IMPORTANT: This method must be called after the main application has been initialized in order to work,\r\n     * otherwise it will do nothing.\r\n     */\r\n    addCloseApplicationWarning() {\r\n\r\n        if (this._windowBeforeUnloadUnListen === null) {\r\n\r\n            this._windowBeforeUnloadUnListen = this._renderer.listen('window', 'beforeunload',\r\n                (event) => event.returnValue = true);\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Remove the close application warning message if previously assigned\r\n     */\r\n    removeCloseApplicationWarning() {\r\n\r\n        if (this._windowBeforeUnloadUnListen !== null) {\r\n\r\n            this._windowBeforeUnloadUnListen();\r\n            this._windowBeforeUnloadUnListen = null;\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Change the application visual appearance so the user perceives that the application is\r\n     * currently busy. While modal busy state is enabled, no user input is possible neither via\r\n     * keyboard, mouse or touch. Use this state when performing server requests or operations that\r\n     * must block the user interaction with the application.\r\n     *\r\n     * Note: We can modify the busy state component that is shown by this method. To do it, we must\r\n     * set this.customBusyStateComponentClass property with our own custom busy state component class. (We can do it at\r\n     * our main application component constructor for example). Our custom component must extend the\r\n     * BusyStateBaseComponent one to add its own visual appearance.\r\n     *\r\n     * @see this.customBusyStateComponentClass\r\n     */\r\n    addModalBusyState() {\r\n\r\n        if (!this._isEnabled || this._isShowingBusyState) {\r\n\r\n            return;\r\n        }\r\n\r\n        this._disableUserInteraction();\r\n\r\n        // Dynamically create the busy state component reference if this is the first time\r\n        if (this._componentPortal === null) {\r\n\r\n            this._componentPortal = new ComponentPortal(this.customBusyStateComponentClass);\r\n\r\n            // Create a PortalHost with document.body as its anchor element\r\n            this._modalBusyStateHost = new DomPortalOutlet(\r\n                    document.body,\r\n                    this.componentFactoryResolver,\r\n                    this.applicationRef,\r\n                    this.injector);\r\n        }\r\n\r\n        (this._modalBusyStateHost as DomPortalOutlet).attach(this._componentPortal);\r\n\r\n        this._isShowingBusyState = true;\r\n    }\r\n\r\n\r\n    /**\r\n     * Tells if the application is currently locked in a modal busy state (caused by an addModalBusyState() call)\r\n     */\r\n    get isShowingBusyState() {\r\n\r\n        return this._isShowingBusyState;\r\n    }\r\n\r\n\r\n    /**\r\n     * Remove the application busy state and restore it back to normal user interaction\r\n     */\r\n    removeModalBusyState() {\r\n\r\n        if (!this._isEnabled || !this._isShowingBusyState) {\r\n\r\n            return;\r\n        }\r\n\r\n        if (this._componentPortal !== null) {\r\n\r\n            (this._modalBusyStateHost as DomPortalOutlet).detach();\r\n        }\r\n\r\n        this._enableUserInteraction();\r\n\r\n        this._isShowingBusyState = false;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * TODO - adapt from TS version\r\n     */\r\n    addToolTip() {\r\n\r\n        // TODO - adapt from TS version\r\n    }\r\n\r\n\r\n    /**\r\n     * Show a non modal snackbar notification to the user (Only one snack-bar can ever be opened at the same time).\r\n     *\r\n     * Snackbars inform users of a process that an app has performed or will perform. They appear temporarily, towards the bottom or top of the screen.\r\n     * They shouldn’t interrupt the user experience, and they don’t require user input to disappear.\r\n     *\r\n     * @param config A MatSnackBarConfig instance with the customizations we want for this snackbar\r\n     * @param message The message to show on the snackbar\r\n     * @param action If not empty, the text to place on the snackbar confirmation button\r\n     * @param actionCallback A method to execute once the user clicks into the action button.\r\n     *\r\n     * @return void\r\n     */\r\n    addSnackBar(config: MatSnackBarConfig, message: string, action = '', actionCallback: (() => void) | null = null) {\r\n\r\n        if (!this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n\r\n        if (this._isShowingSnackBar) {\r\n\r\n            throw new Error('Trying to show a snackbar while another one is still visible');\r\n        }\r\n\r\n        this._isShowingSnackBar = true;\r\n\r\n        const snackBarRef = this.matSnackBar.open(message, action === '' ? undefined : action, config);\r\n\r\n        if (actionCallback !== null) {\r\n\r\n            snackBarRef.onAction().subscribe(() => {\r\n\r\n                actionCallback();\r\n            });\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Tells if the application is currently showing a snackbar or not\r\n     */\r\n    get isShowingSnackBar() {\r\n\r\n        return this._isShowingSnackBar;\r\n    }\r\n\r\n\r\n    /**\r\n     * Force the removal of the snack bar dialog if it exists.\r\n     *\r\n     * If no snackbar is currently visible, this method will do nothing\r\n     */\r\n    removeSnackBar() {\r\n\r\n        if (!this._isEnabled || !this._isShowingSnackBar) {\r\n\r\n            return;\r\n        }\r\n\r\n        this.matSnackBar.dismiss();\r\n\r\n        this._isShowingSnackBar = false;\r\n    }\r\n\r\n\r\n    /**\r\n     * Show a dialog with one or more options that can be used to close it. We can use any of the predefined dialog types that are bundled with\r\n     * this library or extend DialogBaseComponent to create our own custom ones.\r\n     *\r\n     * @param dialogComponentClass A class for a component that extends DialogBaseComponent, which will be the dialog that is shown to the user.\r\n     * @param properties An object containing the different visual and textual options that this dialog allows:\r\n     *            - width: Specify the css value for the default dialog width. As the dialog is responsive, the value will be automatically\r\n     *              reduced if the available screen is not enough, and will reach the desired value otherwise. We can set any css unit like pixels, \r\n     *              %, vh, vw, or any other. For example: '400px', '50%', etc.\r\n     *            - maxWidth: Defines the maximum width that the dialog will have regarding the viewport. We can specify it in % or vw, just like is done in\r\n     *              css. By default it is defined as 96vw, which will fit 96% of the viewport on small devices\r\n     *            - height: TODO docs\r\n     *            - maxHeight: TODO docs\r\n     *            - modal: True (default) if selecting an option is mandatory to close the dialog, false if the dialog can be closed\r\n     *              by the user clicking outside it \r\n     *            - texts: A list with strings containing the dialog texts, sorted by importance. When dialog has a title, this should\r\n     *              be placed first, subtitle second and so (Each dialog may accept different number of texts).\r\n     *            - options: A list of strings that will be used as button captions for each one of the accepted dialog options\r\n     * \r\n     * @param callback A function that will be called after the dialog is closed and will receive a selection object with the numeric index and value for\r\n     *        the option that's been selected by the user. if no option was selected, index will be -1 and value null\r\n     */\r\n    addDialog(dialogComponentClass: Type<DialogBaseComponent>,\r\n              properties: {width?: string,\r\n                           maxWidth?: string,\r\n                           height?: string,\r\n                           maxHeight?: string,\r\n                           modal?: boolean,\r\n                           texts?: string[],\r\n                           options?: string[]}, \r\n              callback: null | ((selection: {index:number, value?: any}) => void) = null) {\r\n\r\n        if (!this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n        \r\n        // Set the default values for non specified properties\r\n        properties.modal = properties.modal ?? true;\r\n        properties.texts = properties.texts ?? [];\r\n        properties.options = properties.options ?? [];\r\n\r\n        // Generate a string to uniquely identify this dialog on the list of active dialogs\r\n        const dialogHash = properties.texts.join('') + properties.options.join('') + dialogComponentClass.name;\r\n\r\n        // identical dialogs won't be allowed at the same time\r\n        if (this._activeDialogs.includes(dialogHash)) {\r\n\r\n            return;\r\n        }\r\n\r\n        const dialogRef = this.matDialog.open(dialogComponentClass, {\r\n            width: properties.width ?? \"50%\",\r\n            maxWidth: properties.maxWidth ?? \"96vw\",\r\n            disableClose: properties.modal,\r\n            autoFocus: false,\r\n            closeOnNavigation: !properties.modal,\r\n            data: { texts: properties.texts, options: properties.options }\r\n          });\r\n\r\n        this._activeDialogs.push(dialogHash);\r\n        this._activeDialogInstances.push(dialogRef);\r\n\r\n        dialogRef.beforeClosed().subscribe((selection:{index:number, value?:any}) => {\r\n\r\n            this._activeDialogs = ArrayUtils.removeElement(this._activeDialogs, dialogHash);\r\n            this._activeDialogInstances = ArrayUtils.removeElement(this._activeDialogInstances, dialogRef);\r\n\r\n            if(!properties.modal && selection === undefined){\r\n            \r\n                selection = { index: -1 };\r\n            \r\n            }else if (!NumericUtils.isInteger(selection.index)) {\r\n\r\n                throw new Error(`closeDialog() expects index to be an integer`);               \r\n            }\r\n\r\n            if (callback !== null) {\r\n\r\n                if(selection.index >= 0 && selection.value === null){\r\n                    \r\n                    selection.value = properties.options![selection.index];\r\n                }\r\n\r\n                (callback as ((selection:{index:number, value?:any}) => void))(selection);\r\n            }\r\n        });\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Force the removal of all the dialogs that are currently visible.\r\n     *\r\n     * If no dialogs are currently visible, this method will do nothing\r\n     */\r\n    removeAllDialogs() {\r\n\r\n        if (!this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n\r\n        for (const dialogRef of this._activeDialogInstances) {\r\n\r\n            dialogRef.close({index:-1});\r\n        }\r\n        \r\n        this._activeDialogs = [];\r\n        this._activeDialogInstances = [];\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Show a dialog with a calendar to let the user pick a date.\r\n     *\r\n     * @param properties An object containing the different visual and textual options that this dialog allows:\r\n     *            - width: Specify the css value for the default dialog width. As the dialog is responsive, the value will be automatically\r\n     *              reduced if the available screen is not enough, and will reach the desired value otherwise. We can set any css unit like pixels, \r\n     *              %, vh, vw, or any other. For example: '400px', '50%', etc.\r\n     *            - maxWidth: Defines the maximum width that the dialog will have regarding the viewport. We can specify it in % or vw, just like is done in\r\n     *              css. By default it is defined as 96vw, which will fit 96% of the viewport on small devices\r\n     *            - height: TODO docs\r\n     *            - maxHeight: TODO docs\r\n     *            - modal: True (default) if selecting an option is mandatory to close the dialog, false if the dialog can be closed\r\n     *              by the user clicking outside it \r\n     *            - title: An optional dialog title\r\n     * @param callback A function to be called after the dialog is closed. It will receive a Date() object selected by the user or null if no selection happened\r\n     */\r\n    addDateSelectionDialog(properties: {width?: string,\r\n                                        maxWidth?: string,\r\n                                        height?: string,\r\n                                        maxHeight?: string,\r\n                                        modal?: boolean\r\n                                        title?: string},\r\n                           callback: ((selectedDate: null | Date) => void)) {\r\n\r\n        if (!this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n        \r\n        this.addDialog(DialogDateSelectionComponent,\r\n            {\r\n                width: properties.width ?? \"50%\",\r\n                maxWidth: properties.maxWidth ?? \"96vw\",\r\n                height: properties.height ?? \"50%\",\r\n                maxHeight: properties.maxHeight ?? \"92vw\",\r\n                modal: properties.modal ?? false,\r\n                texts: [properties.title ?? '']   \r\n            },(selection) => {\r\n                \r\n                callback(selection.index === -1 ? null : (selection.value as Date));  \r\n            });\r\n    }\r\n\r\n\r\n    /**\r\n     * Block all the user interactions with the application (keyboard, touch, mouse, ...)\r\n     */\r\n    private _disableUserInteraction() {\r\n\r\n        if (this._documentKeydownUnlisten === null) {\r\n\r\n            this._documentKeydownUnlisten = this._renderer.listen('document', 'keydown', (event) => event.preventDefault());\r\n        }\r\n\r\n        if (this._documentMousedownUnlisten === null) {\r\n\r\n            this._documentMousedownUnlisten = this._renderer.listen('document', 'mousedown', (event) => event.preventDefault());\r\n        }\r\n\r\n        if (this._documentPointerdownUnlisten === null) {\r\n\r\n            this._documentPointerdownUnlisten = this._renderer.listen('document', 'pointerdown', (event) => event.preventDefault());\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Restore the user interactions that were previously disabled with _disableUserInteraction method\r\n     */\r\n    private _enableUserInteraction() {\r\n\r\n        if (this._documentKeydownUnlisten !== null) {\r\n\r\n            this._documentKeydownUnlisten();\r\n            this._documentKeydownUnlisten = null;\r\n        }\r\n\r\n        if (this._documentMousedownUnlisten !== null) {\r\n\r\n            this._documentMousedownUnlisten();\r\n            this._documentMousedownUnlisten = null;\r\n        }\r\n\r\n        if (this._documentPointerdownUnlisten !== null) {\r\n\r\n            this._documentPointerdownUnlisten();\r\n            this._documentMousedownUnlisten = null;\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2022/main/controller/http.service.mjs

@@ -55,7 +55,7 @@ export class HTTPService extends HTTPManager {
                         this.dialogService.addDialog(DialogErrorComponent, {
                             width: '600px',
                             texts: ['Error: ' + result.code, errorMsg],
-                            captions: ['Ok']
+                            options: ['Ok']
                         });
                     }
                 }
@@ -71,4 +71,4 @@ export class HTTPService extends HTTPManager {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: HTTPService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.DialogService }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/main/view/components/dialog-base/dialog-base.component.mjs

@@ -10,5 +10,20 @@
  * This is the base class for all the dialog components that can be loaded by the dialog service class
  */
 export class DialogBaseComponent {
+    /**
+     * Method to be called by the dialogs that extend this base component when they want to close themselves.
+     * It will perform the close of that dialog and also send an object to the addDialog() callback with the index and value
+     * that the user may have selected.
+     *
+     * @param dialogRef The reference to the dialogRef object that is available at the extended dialog component. It is
+     *        required to perform the closing operation
+     * @param index The numeric index of the user option selection. It will be specific for each dialog and it's different available options
+     * @param value Any value that may be provided to the callback regarding the user selected option.
+     *
+     * @return void
+     */
+    closeDialog(dialogRef, index, value = null) {
+        dialogRef.close({ index: index, value: value });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLWJhc2UuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHVyYm9ndWktYW5ndWxhci9zcmMvbWFpbi92aWV3L2NvbXBvbmVudHMvZGlhbG9nLWJhc2UvZGlhbG9nLWJhc2UuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFHSDs7R0FFRztBQUNILE1BQU0sT0FBZ0IsbUJBQW1CO0NBRXhDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIFR1cmJvR1VJIGlzIEEgbGlicmFyeSB0aGF0IGhlbHBzIHdpdGggdGhlIG1vc3QgY29tbW9uIGFuZCBnZW5lcmljIFVJIGVsZW1lbnRzIGFuZCBmdW5jdGlvbmFsaXRpZXNcclxuICpcclxuICogV2Vic2l0ZSA6IC0+IGh0dHA6Ly93d3cudHVyYm9ndWkub3JnXHJcbiAqIExpY2Vuc2UgOiAtPiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wLiBZb3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXHJcbiAqIExpY2Vuc2UgVXJsIDogLT4gaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXHJcbiAqIENvcHlSaWdodCA6IC0+IENvcHlyaWdodCAyMDE4IEVkZXJ0b25lIEFkdmFuZGVkIFNvbHV0aW9ucy4gaHR0cHM6Ly93d3cuZWRlcnRvbmUuY29tXHJcbiAqL1xyXG5cclxuXHJcbi8qKlxyXG4gKiBUaGlzIGlzIHRoZSBiYXNlIGNsYXNzIGZvciBhbGwgdGhlIGRpYWxvZyBjb21wb25lbnRzIHRoYXQgY2FuIGJlIGxvYWRlZCBieSB0aGUgZGlhbG9nIHNlcnZpY2UgY2xhc3NcclxuICovXHJcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBEaWFsb2dCYXNlQ29tcG9uZW50IHtcclxuXHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/main/view/components/dialog-date-selection/dialog-date-selection.component.mjs

@@ -8,39 +8,27 @@
  */
 import { Component, Inject } from '@angular/core';
 import { MAT_DIALOG_DATA } from '@angular/material/dialog';
-import { DialogOptionsBaseComponent } from '../dialog-options-base/dialog-options-base.component';
+import { DialogBaseComponent } from '../dialog-base/dialog-base.component';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/material/dialog";
 import * as i2 from "@angular/material/datepicker";
 /**
  * A dialog component with a calendar that allows us to select a single date value
  */
-export class DialogDateSelectionComponent extends DialogOptionsBaseComponent {
+export class DialogDateSelectionComponent extends DialogBaseComponent {
     constructor(dialogRef, data) {
         super();
         this.dialogRef = dialogRef;
         this.data = data;
-        //        if (data.texts.length < 1) {
-        //
-        //            throw new Error('DialogErrorComponent expects 2 texts: The title and optionally a description');
-        //        }
-        //
-        //        if (data.options.length !== 1) {
-        //
-        //            throw new Error('DialogErrorComponent expects only one option');
-        //        }
-    }
-    onDateSelected(event) {
-        alert(`Selected: ${event}`);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: DialogDateSelectionComponent, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.8", type: DialogDateSelectionComponent, selector: "tg-dialog-date-selection", usesInheritance: true, ngImport: i0, template: "<h2>{{data.texts[0]}}</h2>\r\n\r\n<mat-calendar #calendar\r\n    (selectedChange)=\"onDateSelected($event)\">\r\n</mat-calendar>", styles: [":host{position:relative;min-height:300px}h1{margin-top:0;margin-bottom:25px;width:82%}\n"], dependencies: [{ kind: "component", type: i2.MatCalendar, selector: "mat-calendar", inputs: ["headerComponent", "startAt", "startView", "selected", "minDate", "maxDate", "dateFilter", "dateClass", "comparisonStart", "comparisonEnd", "startDateAccessibleName", "endDateAccessibleName"], outputs: ["selectedChange", "yearSelected", "monthSelected", "viewChanged", "_userSelection", "_userDragDrop"], exportAs: ["matCalendar"] }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.8", type: DialogDateSelectionComponent, selector: "tg-dialog-date-selection", usesInheritance: true, ngImport: i0, template: "<h2>{{data.texts[0]}}</h2>\r\n\r\n<mat-calendar #calendar\r\n    (selectedChange)=\"closeDialog(dialogRef, 0, $event)\">\r\n</mat-calendar>", styles: [":host{position:relative;min-height:300px}h1{margin-top:0;margin-bottom:25px;width:82%}\n"], dependencies: [{ kind: "component", type: i2.MatCalendar, selector: "mat-calendar", inputs: ["headerComponent", "startAt", "startView", "selected", "minDate", "maxDate", "dateFilter", "dateClass", "comparisonStart", "comparisonEnd", "startDateAccessibleName", "endDateAccessibleName"], outputs: ["selectedChange", "yearSelected", "monthSelected", "viewChanged", "_userSelection", "_userDragDrop"], exportAs: ["matCalendar"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: DialogDateSelectionComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'tg-dialog-date-selection', template: "<h2>{{data.texts[0]}}</h2>\r\n\r\n<mat-calendar #calendar\r\n    (selectedChange)=\"onDateSelected($event)\">\r\n</mat-calendar>", styles: [":host{position:relative;min-height:300px}h1{margin-top:0;margin-bottom:25px;width:82%}\n"] }]
+            args: [{ selector: 'tg-dialog-date-selection', template: "<h2>{{data.texts[0]}}</h2>\r\n\r\n<mat-calendar #calendar\r\n    (selectedChange)=\"closeDialog(dialogRef, 0, $event)\">\r\n</mat-calendar>", styles: [":host{position:relative;min-height:300px}h1{margin-top:0;margin-bottom:25px;width:82%}\n"] }]
         }], ctorParameters: () => [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [MAT_DIALOG_DATA]
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/main/view/components/dialog-error/dialog-error.component.mjs

@@ -8,7 +8,7 @@
  */
 import { Component, Inject } from '@angular/core';
 import { MAT_DIALOG_DATA } from '@angular/material/dialog';
-import { DialogOptionsBaseComponent } from '../dialog-options-base/dialog-options-base.component';
+import { DialogBaseComponent } from '../dialog-base/dialog-base.component';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/material/dialog";
 import * as i2 from "@angular/material/button";
@@ -16,7 +16,7 @@ import * as i3 from "@angular/common";
 /**
  * A dialog component with a single option button, to be used for error notifications
  */
-export class DialogErrorComponent extends DialogOptionsBaseComponent {
+export class DialogErrorComponent extends DialogBaseComponent {
     constructor(dialogRef, data) {
         super();
         this.dialogRef = dialogRef;
@@ -29,13 +29,13 @@ export class DialogErrorComponent extends DialogOptionsBaseComponent {
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: DialogErrorComponent, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.8", type: DialogErrorComponent, selector: "tg-dialog-error", usesInheritance: true, ngImport: i0, template: "<div class=\"titleAndIconContainer\">\r\n    <h3>\r\n        {{data.texts[0]}}\r\n    </h3>\r\n    \r\n    <!-- error icon -->\r\n    <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24\" viewBox=\"0 0 24 24\" width=\"24\">\r\n        <path d=\"M0 0h24v24H0z\" fill=\"none\"/>\r\n        <path d=\"M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z\" fill=\"#ff0000\" />\r\n    </svg>\r\n    \r\n</div>\r\n\r\n<p *ngIf=\"data.texts.length > 1\">\r\n    {{data.texts[1]}}\r\n</p>\r\n\r\n<button mat-raised-button color=\"warn\"\r\n    (click)=\"dialogRef.close(0)\">\r\n    \r\n    {{data.options[0]}}\r\n    \r\n</button>", styles: [":host{position:relative;min-height:300px}.titleAndIconContainer{display:flex;flex-direction:row;align-items:center}h3{margin-top:0;margin-bottom:25px;width:82%}svg{width:18%;height:auto}p{margin-bottom:52px}button{float:right;width:50%;min-width:50px}\n"], dependencies: [{ kind: "component", type: i2.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.8", type: DialogErrorComponent, selector: "tg-dialog-error", usesInheritance: true, ngImport: i0, template: "<div class=\"titleAndIconContainer\">\r\n    <h3>\r\n        {{data.texts[0]}}\r\n    </h3>\r\n    \r\n    <!-- error icon -->\r\n    <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24\" viewBox=\"0 0 24 24\" width=\"24\">\r\n        <path d=\"M0 0h24v24H0z\" fill=\"none\"/>\r\n        <path d=\"M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z\" fill=\"#ff0000\" />\r\n    </svg>\r\n    \r\n</div>\r\n\r\n<p *ngIf=\"data.texts.length > 1\">\r\n    {{data.texts[1]}}\r\n</p>\r\n\r\n<button mat-raised-button color=\"warn\"\r\n    (click)=\"closeDialog(dialogRef, 0)\">\r\n    \r\n    {{data.options[0]}}\r\n    \r\n</button>", styles: [":host{position:relative;min-height:300px}.titleAndIconContainer{display:flex;flex-direction:row;align-items:center}h3{margin-top:0;margin-bottom:25px;width:82%}svg{width:18%;height:auto}p{margin-bottom:52px}button{float:right;width:50%;min-width:50px}\n"], dependencies: [{ kind: "component", type: i2.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: DialogErrorComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'tg-dialog-error', template: "<div class=\"titleAndIconContainer\">\r\n    <h3>\r\n        {{data.texts[0]}}\r\n    </h3>\r\n    \r\n    <!-- error icon -->\r\n    <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24\" viewBox=\"0 0 24 24\" width=\"24\">\r\n        <path d=\"M0 0h24v24H0z\" fill=\"none\"/>\r\n        <path d=\"M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z\" fill=\"#ff0000\" />\r\n    </svg>\r\n    \r\n</div>\r\n\r\n<p *ngIf=\"data.texts.length > 1\">\r\n    {{data.texts[1]}}\r\n</p>\r\n\r\n<button mat-raised-button color=\"warn\"\r\n    (click)=\"dialogRef.close(0)\">\r\n    \r\n    {{data.options[0]}}\r\n    \r\n</button>", styles: [":host{position:relative;min-height:300px}.titleAndIconContainer{display:flex;flex-direction:row;align-items:center}h3{margin-top:0;margin-bottom:25px;width:82%}svg{width:18%;height:auto}p{margin-bottom:52px}button{float:right;width:50%;min-width:50px}\n"] }]
+            args: [{ selector: 'tg-dialog-error', template: "<div class=\"titleAndIconContainer\">\r\n    <h3>\r\n        {{data.texts[0]}}\r\n    </h3>\r\n    \r\n    <!-- error icon -->\r\n    <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24\" viewBox=\"0 0 24 24\" width=\"24\">\r\n        <path d=\"M0 0h24v24H0z\" fill=\"none\"/>\r\n        <path d=\"M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z\" fill=\"#ff0000\" />\r\n    </svg>\r\n    \r\n</div>\r\n\r\n<p *ngIf=\"data.texts.length > 1\">\r\n    {{data.texts[1]}}\r\n</p>\r\n\r\n<button mat-raised-button color=\"warn\"\r\n    (click)=\"closeDialog(dialogRef, 0)\">\r\n    \r\n    {{data.options[0]}}\r\n    \r\n</button>", styles: [":host{position:relative;min-height:300px}.titleAndIconContainer{display:flex;flex-direction:row;align-items:center}h3{margin-top:0;margin-bottom:25px;width:82%}svg{width:18%;height:auto}p{margin-bottom:52px}button{float:right;width:50%;min-width:50px}\n"] }]
         }], ctorParameters: () => [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [MAT_DIALOG_DATA]
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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