turbogui-angular 7.0.0 → 8.0.0

package/esm2020/main/controller/browser.service.mjs

@@ -0,0 +1,48 @@
+/**
+ * TurboGUI is A library that helps with the most common and generic UI elements and functionalities
+ *
+ * Website : -> http://www.turbogui.org
+ * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.
+ * License Url : -> http://www.apache.org/licenses/LICENSE-2.0
+ * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com
+ */
+import { Injectable } from '@angular/core';
+import { BrowserManager } from 'turbocommons-ts';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * An abstraction of the browser entity an all its related operations and properties
+ */
+export class BrowserService extends BrowserManager {
+    constructor(location) {
+        super();
+        this.location = location;
+    }
+    /**
+     * Modify the current browser URI without reloading the current page document
+     *
+     * @param path The uri value we want to set
+     * @param query The query url parameters part we want to specify if any
+     *
+     * @returns void
+     */
+    setURI(path, query) {
+        this.location.go(path, query);
+    }
+    /**
+     * Obtain a subscription to get notified on any changes at the browser url
+     *
+     * @param onNext A method to be executed every time the url changes on the browser. The url will be available inside the value parameter
+     *
+     * @returns Subscribed events. Make sure to unsubscribe when not needed
+     */
+    subscribeToUrlChange(onNext) {
+        return this.location.subscribe(onNext);
+    }
+}
+BrowserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: BrowserService, deps: [{ token: i1.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+BrowserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: BrowserService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: BrowserService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3Nlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHVyYm9ndWktYW5ndWxhci9zcmMvbWFpbi9jb250cm9sbGVyL2Jyb3dzZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7OztHQU9HO0FBRUgsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0saUJBQWlCLENBQUM7OztBQUlqRDs7R0FFRztBQUVILE1BQU0sT0FBTyxjQUFlLFNBQVEsY0FBYztJQUc5QyxZQUE2QixRQUFrQjtRQUUzQyxLQUFLLEVBQUUsQ0FBQztRQUZpQixhQUFRLEdBQVIsUUFBUSxDQUFVO0lBRy9DLENBQUM7SUFHRDs7Ozs7OztPQU9HO0lBQ0gsTUFBTSxDQUFDLElBQVksRUFBRSxLQUEwQjtRQUUzQyxJQUFJLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDbEMsQ0FBQztJQUdEOzs7Ozs7T0FNRztJQUNILG9CQUFvQixDQUFDLE1BQXNDO1FBRXZELE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDM0MsQ0FBQzs7MkdBakNRLGNBQWM7K0dBQWQsY0FBYzsyRkFBZCxjQUFjO2tCQUQxQixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIFR1cmJvR1VJIGlzIEEgbGlicmFyeSB0aGF0IGhlbHBzIHdpdGggdGhlIG1vc3QgY29tbW9uIGFuZCBnZW5lcmljIFVJIGVsZW1lbnRzIGFuZCBmdW5jdGlvbmFsaXRpZXNcclxuICpcclxuICogV2Vic2l0ZSA6IC0+IGh0dHA6Ly93d3cudHVyYm9ndWkub3JnXHJcbiAqIExpY2Vuc2UgOiAtPiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wLiBZb3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXHJcbiAqIExpY2Vuc2UgVXJsIDogLT4gaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXHJcbiAqIENvcHlSaWdodCA6IC0+IENvcHlyaWdodCAyMDE4IEVkZXJ0b25lIEFkdmFuZGVkIFNvbHV0aW9ucy4gaHR0cHM6Ly93d3cuZWRlcnRvbmUuY29tXHJcbiAqL1xyXG5cclxuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBCcm93c2VyTWFuYWdlciB9IGZyb20gJ3R1cmJvY29tbW9ucy10cyc7XHJcbmltcG9ydCB7IExvY2F0aW9uLCBQb3BTdGF0ZUV2ZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuXHJcblxyXG4vKipcclxuICogQW4gYWJzdHJhY3Rpb24gb2YgdGhlIGJyb3dzZXIgZW50aXR5IGFuIGFsbCBpdHMgcmVsYXRlZCBvcGVyYXRpb25zIGFuZCBwcm9wZXJ0aWVzXHJcbiAqL1xyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBCcm93c2VyU2VydmljZSBleHRlbmRzIEJyb3dzZXJNYW5hZ2VyIHtcclxuXHJcblxyXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBsb2NhdGlvbjogTG9jYXRpb24pIHtcclxuXHJcbiAgICAgICAgc3VwZXIoKTtcclxuICAgIH1cclxuXHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBNb2RpZnkgdGhlIGN1cnJlbnQgYnJvd3NlciBVUkkgd2l0aG91dCByZWxvYWRpbmcgdGhlIGN1cnJlbnQgcGFnZSBkb2N1bWVudFxyXG4gICAgICpcclxuICAgICAqIEBwYXJhbSBwYXRoIFRoZSB1cmkgdmFsdWUgd2Ugd2FudCB0byBzZXRcclxuICAgICAqIEBwYXJhbSBxdWVyeSBUaGUgcXVlcnkgdXJsIHBhcmFtZXRlcnMgcGFydCB3ZSB3YW50IHRvIHNwZWNpZnkgaWYgYW55XHJcbiAgICAgKlxyXG4gICAgICogQHJldHVybnMgdm9pZFxyXG4gICAgICovXHJcbiAgICBzZXRVUkkocGF0aDogc3RyaW5nLCBxdWVyeT86IHN0cmluZyB8IHVuZGVmaW5lZCl7XHJcblxyXG4gICAgICAgIHRoaXMubG9jYXRpb24uZ28ocGF0aCwgcXVlcnkpO1xyXG4gICAgfVxyXG4gICAgXHJcbiAgICBcclxuICAgIC8qKlxyXG4gICAgICogT2J0YWluIGEgc3Vic2NyaXB0aW9uIHRvIGdldCBub3RpZmllZCBvbiBhbnkgY2hhbmdlcyBhdCB0aGUgYnJvd3NlciB1cmxcclxuICAgICAqXHJcbiAgICAgKiBAcGFyYW0gb25OZXh0IEEgbWV0aG9kIHRvIGJlIGV4ZWN1dGVkIGV2ZXJ5IHRpbWUgdGhlIHVybCBjaGFuZ2VzIG9uIHRoZSBicm93c2VyLiBUaGUgdXJsIHdpbGwgYmUgYXZhaWxhYmxlIGluc2lkZSB0aGUgdmFsdWUgcGFyYW1ldGVyXHJcbiAgICAgKlxyXG4gICAgICogQHJldHVybnMgU3Vic2NyaWJlZCBldmVudHMuIE1ha2Ugc3VyZSB0byB1bnN1YnNjcmliZSB3aGVuIG5vdCBuZWVkZWRcclxuICAgICAqL1xyXG4gICAgc3Vic2NyaWJlVG9VcmxDaGFuZ2Uob25OZXh0OiAodmFsdWU6IFBvcFN0YXRlRXZlbnQpID0+IHZvaWQpe1xyXG4gICAgICAgIFxyXG4gICAgICAgIHJldHVybiB0aGlzLmxvY2F0aW9uLnN1YnNjcmliZShvbk5leHQpO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,324 @@
+/**
+ * TurboGUI is A library that helps with the most common and generic UI elements and functionalities
+ *
+ * Website : -> http://www.turbogui.org
+ * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.
+ * License Url : -> http://www.apache.org/licenses/LICENSE-2.0
+ * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com
+ */
+import { ArrayUtils, NumericUtils } from 'turbocommons-ts';
+import { Injectable } from '@angular/core';
+import { BusyStateBaseComponent } from '../view/components/busy-state-base/busy-state-base.component';
+import { ComponentPortal, DomPortalOutlet } from '@angular/cdk/portal';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+import * as i2 from "@angular/material/dialog";
+/**
+ * Manages the application modal and non modal floating elements
+ */
+export class DialogService {
+    constructor(rendererFactory, matSnackBar, matDialog, injector, applicationRef, componentFactoryResolver) {
+        this.matSnackBar = matSnackBar;
+        this.matDialog = matDialog;
+        this.injector = injector;
+        this.applicationRef = applicationRef;
+        this.componentFactoryResolver = componentFactoryResolver;
+        /**
+         * Used to modify the busy state component that is shown by default by the addModalBusyState() method.
+         *
+         * @see this.addModalBusyState()
+         */
+        this.customBusyStateComponentClass = BusyStateBaseComponent;
+        /**
+         * Check public getter for docs
+         */
+        this._isEnabled = true;
+        /**
+         * Tells if the main application is currently showing a busy state that blocks all user interaction
+         */
+        this._isShowingBusyState = false;
+        /**
+         * A reference to the modal busy state component that is initialized only the first time it is called.
+         *
+         * (To append the busy state dynamically, we use the Portal concept from the angular material library)
+         */
+        this._componentPortal = null;
+        /**
+         * A reference to the modal busy state container where the component will be added
+         */
+        this._modalBusyStateHost = null;
+        /**
+         * Tells if the manager is currently showing a snackbar element or not
+         */
+        this._isShowingSnackBar = false;
+        /**
+         * Contains a list of the dialogs that are currently visible to the user.
+         * Each item in this list is a hash that is computed when dialog is created to uniquely identify it.
+         *
+         * Empty list means no dialogs are currently visible
+         */
+        this._activeDialogs = [];
+        /**
+         * Contains a list with all the MatDialog instances that are currently visible to the user.
+         * The list uses the same order as the list of _activeDialogs hash values
+         */
+        this._activeDialogInstances = [];
+        /**
+         * Method that is used to delete the window beforeunload event listener once not used anymore
+         */
+        this._windowBeforeUnloadUnListen = null;
+        /**
+         * Method that is used to delete the document keydown event listener once not used anymore
+         */
+        this._documentKeydownUnlisten = null;
+        /**
+         * Method that is used to delete the document mousedown event listener once not used anymore
+         */
+        this._documentMousedownUnlisten = null;
+        /**
+         * Method that is used to delete the document pointerdown event listener once not used anymore
+         */
+        this._documentPointerdownUnlisten = null;
+        this._renderer = rendererFactory.createRenderer(null, null);
+    }
+    /**
+     * Tells if this dialog service is enabled or not. If dialog service is disabled, none of it's features will work
+     * This is used to block all dialog features normally when shutting down the application
+     *
+     * Use with caution. When this is set to false, dialog service stops working.
+     */
+    set isEnabled(v) {
+        if (v === this._isEnabled) {
+            return;
+        }
+        this._isEnabled = v;
+    }
+    /**
+     * Enables a warning that will be shown to the user when he/she tries to close the application.
+     * This warning will prompt the user to continue with the exit process or cancel it.
+     * The specific texts of this message are a generic ones and cannot be changed.
+     *
+     * IMPORTANT: This method must be called after the main application has been initialized in order to work,
+     * otherwise it will do nothing.
+     */
+    addCloseApplicationWarning() {
+        if (this._windowBeforeUnloadUnListen === null) {
+            this._windowBeforeUnloadUnListen = this._renderer.listen('window', 'beforeunload', (event) => event.returnValue = true);
+        }
+    }
+    /**
+     * Remove the close application warning message if previously assigned
+     */
+    removeCloseApplicationWarning() {
+        if (this._windowBeforeUnloadUnListen !== null) {
+            this._windowBeforeUnloadUnListen();
+            this._windowBeforeUnloadUnListen = null;
+        }
+    }
+    /**
+     * Change the application visual appearance so the user perceives that the application is
+     * currently busy. While modal busy state is enabled, no user input is possible neither via
+     * keyboard, mouse or touch. Use this state when performing server requests or operations that
+     * must block the user interaction with the application.
+     *
+     * Note: We can modify the busy state component that is shown by this method. To do it, we must
+     * set this.customBusyStateComponentClass property with our own custom busy state component class. (We can do it at
+     * our main application component constructor for example). Our custom component must extend the
+     * BusyStateBaseComponent one to add its own visual appearance.
+     *
+     * @see this.customBusyStateComponentClass
+     */
+    addModalBusyState() {
+        if (!this._isEnabled || this._isShowingBusyState) {
+            return;
+        }
+        this._disableUserInteraction();
+        // Dynamically create the busy state component reference if this is the first time
+        if (this._componentPortal === null) {
+            this._componentPortal = new ComponentPortal(this.customBusyStateComponentClass);
+            // Create a PortalHost with document.body as its anchor element
+            this._modalBusyStateHost = new DomPortalOutlet(document.body, this.componentFactoryResolver, this.applicationRef, this.injector);
+        }
+        this._modalBusyStateHost.attach(this._componentPortal);
+        this._isShowingBusyState = true;
+    }
+    /**
+     * Tells if the application is currently locked in a modal busy state (caused by an addModalBusyState() call)
+     */
+    get isShowingBusyState() {
+        return this._isShowingBusyState;
+    }
+    /**
+     * Remove the application busy state and restore it back to normal user interaction
+     */
+    removeModalBusyState() {
+        if (!this._isEnabled || !this._isShowingBusyState) {
+            return;
+        }
+        if (this._componentPortal !== null) {
+            this._modalBusyStateHost.detach();
+        }
+        this._enableUserInteraction();
+        this._isShowingBusyState = false;
+    }
+    /**
+     * TODO - adapt from TS version
+     */
+    addToolTip() {
+        // TODO - adapt from TS version
+    }
+    /**
+     * Show a non modal snackbar notification to the user (Only one snack-bar can ever be opened at the same time).
+     *
+     * 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.
+     * They shouldn’t interrupt the user experience, and they don’t require user input to disappear.
+     *
+     * @param config A MatSnackBarConfig instance with the customizations we want for this snackbar
+     * @param message The message to show on the snackbar
+     * @param action If not empty, the text to place on the snackbar confirmation button
+     * @param actionCallback A method to execute once the user clicks into the action button.
+     *
+     * @return void
+     */
+    addSnackBar(config, message, action = '', actionCallback = null) {
+        if (!this._isEnabled) {
+            return;
+        }
+        if (this._isShowingSnackBar) {
+            throw new Error('Trying to show a snackbar while another one is still visible');
+        }
+        this._isShowingSnackBar = true;
+        const snackBarRef = this.matSnackBar.open(message, action === '' ? undefined : action, config);
+        if (actionCallback !== null) {
+            snackBarRef.onAction().subscribe(() => {
+                actionCallback();
+            });
+        }
+    }
+    /**
+     * Tells if the application is currently showing a snackbar or not
+     */
+    get isShowingSnackBar() {
+        return this._isShowingSnackBar;
+    }
+    /**
+     * Force the removal of the snack bar dialog if it exists.
+     *
+     * If no snackbar is currently visible, this method will do nothing
+     */
+    removeSnackBar() {
+        if (!this._isEnabled || !this._isShowingSnackBar) {
+            return;
+        }
+        this.matSnackBar.dismiss();
+        this._isShowingSnackBar = false;
+    }
+    /**
+     * 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.
+     *
+     * @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 kind 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.
+     * @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
+     */
+    addDialog(width, texts, options, dialogComponentClass, callback = null, modal = true) {
+        if (!this._isEnabled) {
+            return;
+        }
+        // Generate a string to uniquely identify this dialog on the list of active dialogs
+        const dialogHash = texts.join('') + 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: width,
+            disableClose: modal,
+            autoFocus: false,
+            closeOnNavigation: !modal,
+            data: { texts: texts, options: options }
+        });
+        this._activeDialogs.push(dialogHash);
+        this._activeDialogInstances.push(dialogRef);
+        dialogRef.beforeClosed().subscribe((selectedOptionIndex) => {
+            this._activeDialogs = ArrayUtils.removeElement(this._activeDialogs, dialogHash);
+            this._activeDialogInstances = ArrayUtils.removeElement(this._activeDialogInstances, dialogRef);
+            if (!NumericUtils.isInteger(selectedOptionIndex)) {
+                if (modal) {
+                    throw new Error(`dialogRef.close() expects int value`);
+                }
+                else {
+                    selectedOptionIndex = -1;
+                }
+            }
+            if (callback !== null) {
+                let selectedOption = { index: selectedOptionIndex, value: '' };
+                if (selectedOptionIndex >= 0) {
+                    selectedOption.value = options[selectedOptionIndex];
+                }
+                callback(selectedOption);
+            }
+        });
+    }
+    /**
+     * Force the removal of all the dialogs that are currently visible.
+     *
+     * If no dialogs are currently visible, this method will do nothing
+     */
+    removeAllDialogs() {
+        if (!this._isEnabled) {
+            return;
+        }
+        for (const dialogRef of this._activeDialogInstances) {
+            dialogRef.close(-1);
+        }
+        this._activeDialogs = [];
+        this._activeDialogInstances = [];
+    }
+    /**
+     * Block all the user interactions with the application (keyboard, touch, mouse, ...)
+     */
+    _disableUserInteraction() {
+        if (this._documentKeydownUnlisten === null) {
+            this._documentKeydownUnlisten = this._renderer.listen('document', 'keydown', (event) => event.preventDefault());
+        }
+        if (this._documentMousedownUnlisten === null) {
+            this._documentMousedownUnlisten = this._renderer.listen('document', 'mousedown', (event) => event.preventDefault());
+        }
+        if (this._documentPointerdownUnlisten === null) {
+            this._documentPointerdownUnlisten = this._renderer.listen('document', 'pointerdown', (event) => event.preventDefault());
+        }
+    }
+    /**
+     * Restore the user interactions that were previously disabled with _disableUserInteraction method
+     */
+    _enableUserInteraction() {
+        if (this._documentKeydownUnlisten !== null) {
+            this._documentKeydownUnlisten();
+            this._documentKeydownUnlisten = null;
+        }
+        if (this._documentMousedownUnlisten !== null) {
+            this._documentMousedownUnlisten();
+            this._documentMousedownUnlisten = null;
+        }
+        if (this._documentPointerdownUnlisten !== null) {
+            this._documentPointerdownUnlisten();
+            this._documentMousedownUnlisten = null;
+        }
+    }
+}
+DialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DialogService, deps: [{ token: i0.RendererFactory2 }, { token: i1.MatSnackBar }, { token: i2.MatDialog }, { token: i0.Injector }, { token: i0.ApplicationRef }, { token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Injectable });
+DialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DialogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ 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\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 kind 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.\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     */\r\n    addDialog(width: string,\r\n              texts: string[],\r\n              options: string[],\r\n              dialogComponentClass: Type<DialogOptionsBaseComponent>,\r\n              callback: null | ((selectedOption: {index:number, value: string}) => void) = null,\r\n              modal = true) {\r\n\r\n        if (!this._isEnabled) {\r\n\r\n            return;\r\n        }\r\n\r\n        // Generate a string to uniquely identify this dialog on the list of active dialogs\r\n        const dialogHash = texts.join('') + 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: width,\r\n            disableClose: modal,\r\n            autoFocus: false,\r\n            closeOnNavigation: !modal,\r\n            data: { texts: texts, options: options }\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(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[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    /**\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/esm2020/main/controller/globalerror.service.mjs

@@ -0,0 +1,68 @@
+/**
+ * TurboGUI is A library that helps with the most common and generic UI elements and functionalities
+ *
+ * Website : -> http://www.turbogui.org
+ * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.
+ * License Url : -> http://www.apache.org/licenses/LICENSE-2.0
+ * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Captures all the application exceptions and performs any required action.
+ * It also contains multiple general error management features.
+ *
+ * To define this class as your application error handler, you must add the following to your
+ * main app module providers:
+ *      {
+ *          provide: ErrorHandler,
+ *          useClass: GlobalErrorService
+ *      },
+ *      GlobalErrorService
+ *
+ * You cannot access the error handler at runtime. If you need to modify any of the behaviours
+ * or implement your custom ones, you must extend this class and set your new one as the error
+ * handler provider.
+ */
+export class GlobalErrorService {
+    constructor() {
+        /**
+         * Enables or disables the error notification to user via an alert box
+         * Extend this class and override this value on your custom error handle to change it
+         */
+        this.showExceptionsToUser = true;
+        /**
+         * Enables or disables the error notification to user via an alert box
+         * Extend this class and override this value on your custom error handle to change it
+         */
+        this.showExceptionsOnConsole = true;
+        /**
+         * Defines the text that will be used for the alert that is shown to the user when an exception happens
+         * and showExceptionsToUser is true
+         * Extend this class and override this value on your custom error handle to change it
+         */
+        this.errorAlertMessage = 'Application exception:\n\n';
+    }
+    /**
+     * Show an alert with the received error detail and also log it to the js console.
+     *
+     * Angular expects at least this method to be implemented on any class that is used as a global exception handler.
+     *
+     * @param error An error instance
+     */
+    handleError(error) {
+        if (this.showExceptionsToUser) {
+            alert(this.errorAlertMessage + error);
+        }
+        if (this.showExceptionsOnConsole) {
+            console.log(error);
+        }
+        throw error;
+    }
+}
+GlobalErrorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: GlobalErrorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+GlobalErrorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: GlobalErrorService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: GlobalErrorService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,70 @@
+/**
+ * TurboGUI is A library that helps with the most common and generic UI elements and functionalities
+ *
+ * Website : -> http://www.turbogui.org
+ * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.
+ * License Url : -> http://www.apache.org/licenses/LICENSE-2.0
+ * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com
+ */
+import { Injectable } from '@angular/core';
+import { HTTPManager, StringUtils } from 'turbocommons-ts';
+import { DialogErrorComponent } from '../view/components/dialog-error/dialog-error.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog.service";
+/**
+ * Manages application http communications
+ */
+export class HTTPService extends HTTPManager {
+    constructor(dialogService) {
+        super(true);
+        this.dialogService = dialogService;
+    }
+    /**
+     * The same method as HTTPManager.execute but with the ability to enable several options which are specific to this service:
+     *
+     * - HTTPService.NO_MODAL_BUSY_STATE To prevent the default behaviour of locking the UI while the request is running
+     * - HTTPService.DISABLE_ERROR_HANDLING To prevent the default behaviour of showing a detailed error dialog when a request fails
+     *
+     * @see HTTPManager.execute()
+     */
+    execute(requests, finishedCallback = null, progressCallback = null, options = []) {
+        if (options.indexOf(HTTPService.NO_MODAL_BUSY_STATE) < 0) {
+            this.dialogService.addModalBusyState();
+        }
+        super.execute(requests, (results, anyError) => {
+            if (options.indexOf(HTTPService.NO_MODAL_BUSY_STATE) < 0) {
+                this.dialogService.removeModalBusyState();
+            }
+            if ((options.indexOf(HTTPService.DISABLE_ERROR_HANDLING) < 0) && anyError) {
+                for (let result of results) {
+                    if (result.isError) {
+                        let errorMsg = result.errorMsg + '\n\n' + result.response;
+                        if (StringUtils.isEmpty(errorMsg)) {
+                            errorMsg = 'Unknown error. Make sure Internet connection is available';
+                        }
+                        this.dialogService.addDialog('600px', ['Error: ' + result.code, errorMsg], ['Ok'], DialogErrorComponent);
+                    }
+                }
+            }
+            if (finishedCallback !== null) {
+                finishedCallback(results, anyError);
+            }
+        }, progressCallback);
+    }
+}
+/**
+ * execute() method option that tells the service to avoid blocking the user interface with a modal busy state while the requests that are
+ * launched by the execute method are running.
+ */
+HTTPService.NO_MODAL_BUSY_STATE = 'NO_MODAL_BUSY_STATE';
+/**
+ * execute() method option that tells the service to skip showing an error dialog when a request fails. We normally use this to handle the
+ * errors by ourselves or if we want to hide the error dialog for a specific request.
+ */
+HTTPService.DISABLE_ERROR_HANDLING = 'DISABLE_ERROR_HANDLING';
+HTTPService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: HTTPService, deps: [{ token: i1.DialogService }], target: i0.ɵɵFactoryTarget.Injectable });
+HTTPService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: HTTPService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: HTTPService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DialogService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/main/controller/localization.service.mjs

@@ -0,0 +1,22 @@
+/**
+ * TurboGUI is A library that helps with the most common and generic UI elements and functionalities
+ *
+ * Website : -> http://www.turbogui.org
+ * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.
+ * License Url : -> http://www.apache.org/licenses/LICENSE-2.0
+ * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com
+ */
+import { Injectable } from '@angular/core';
+import { LocalizationManager } from 'turbocommons-ts';
+import * as i0 from "@angular/core";
+/**
+ * Manages application text translations and languages
+ */
+export class LocalizationService extends LocalizationManager {
+}
+LocalizationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: LocalizationService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+LocalizationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: LocalizationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemF0aW9uLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dXJib2d1aS1hbmd1bGFyL3NyYy9tYWluL2NvbnRyb2xsZXIvbG9jYWxpemF0aW9uLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0saUJBQWlCLENBQUM7O0FBR3REOztHQUVHO0FBRUgsTUFBTSxPQUFPLG1CQUFvQixTQUFRLG1CQUFtQjs7Z0hBQS9DLG1CQUFtQjtvSEFBbkIsbUJBQW1COzJGQUFuQixtQkFBbUI7a0JBRC9CLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogVHVyYm9HVUkgaXMgQSBsaWJyYXJ5IHRoYXQgaGVscHMgd2l0aCB0aGUgbW9zdCBjb21tb24gYW5kIGdlbmVyaWMgVUkgZWxlbWVudHMgYW5kIGZ1bmN0aW9uYWxpdGllc1xyXG4gKlxyXG4gKiBXZWJzaXRlIDogLT4gaHR0cDovL3d3dy50dXJib2d1aS5vcmdcclxuICogTGljZW5zZSA6IC0+IExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAuIFlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cclxuICogTGljZW5zZSBVcmwgOiAtPiBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcclxuICogQ29weVJpZ2h0IDogLT4gQ29weXJpZ2h0IDIwMTggRWRlcnRvbmUgQWR2YW5kZWQgU29sdXRpb25zLiBodHRwczovL3d3dy5lZGVydG9uZS5jb21cclxuICovXHJcblxyXG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IExvY2FsaXphdGlvbk1hbmFnZXIgfSBmcm9tICd0dXJib2NvbW1vbnMtdHMnO1xyXG5cclxuXHJcbi8qKlxyXG4gKiBNYW5hZ2VzIGFwcGxpY2F0aW9uIHRleHQgdHJhbnNsYXRpb25zIGFuZCBsYW5ndWFnZXNcclxuICovXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIExvY2FsaXphdGlvblNlcnZpY2UgZXh0ZW5kcyBMb2NhbGl6YXRpb25NYW5hZ2VyIHtcclxuXHJcbn1cclxuIl19