turbogui-angular 6.1.0 → 8.0.0

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

@@ -0,0 +1,56 @@
+/**
+ * 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 { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * This is the main application event bus.
+ * All global events that happen on the application are broadcasted by this service, and
+ * can be listened by any application element who previously subscribed
+ */
+export class NotificationService {
+    constructor() {
+        /**
+         * The Observable instance that handles subscriptions and notifications
+         */
+        this._notifications = new Subject();
+    }
+    /**
+     * used by other services or components to subscribe to all notifications that are generated by this service
+     *
+     * @param notificationHandler A method that will be used to receive each notification as a GUINotification instance
+     *
+     * @returns The new subscription object. Make sure to unsubscribe when not required anymore
+     */
+    subscribe(notificationHandler) {
+        return this._notifications.subscribe(notificationHandler);
+    }
+    /**
+     * Launch a notification to anyone who may be listening
+     *
+     * @param notification A notification instance to launch
+     */
+    send(notification) {
+        this._notifications.next(notification);
+    }
+    /**
+     * End a previously initiated subscription
+     *
+     * @param subscription A previously created subscription instance from which we want to unsubscribe
+     */
+    unsubscribe(subscription) {
+        return subscription.unsubscribe();
+    }
+}
+NotificationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: NotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NotificationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: NotificationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,124 @@
+/**
+ * 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 { ConversionUtils, StringUtils } from 'turbocommons-ts';
+import { HTTPServicePostRequest } from '../controller/httpservice/HTTPServicePostRequest';
+import * as i0 from "@angular/core";
+import * as i1 from "../controller/http.service";
+import * as i2 from "../controller/localization.service";
+/**
+ * Manages the users model and commands
+ */
+export class UserService {
+    constructor(httpService, ls) {
+        this.httpService = httpService;
+        this.ls = ls;
+        /**
+         * Path to the web service that performs the user login
+         */
+        this.loginWebService = 'users/login';
+        /**
+         * The username that is currently defined and will be used by the login methods
+         */
+        this.userName = '';
+        /**
+         * The password for the user that is currently defined and will be used by the login methods
+         */
+        this.password = '';
+        /**
+         * Check public getter for docs
+         */
+        this._isLogged = false;
+        /**
+         * @see token() getter for more info
+         */
+        this._token = '';
+    }
+    /**
+     * Tells if the services contains a non empty username and password specified
+     */
+    get isUserAndPswDefined() {
+        return !StringUtils.isEmpty(this.userName) && !StringUtils.isEmpty(this.password);
+    }
+    /**
+     * Tells if exists a user that is currently logged or not
+     */
+    get isLogged() {
+        return this._isLogged;
+    }
+    /**
+     * Gives the value for the currently active user authentication token or an empty string if no user logged
+     */
+    get token() {
+        return this._token;
+    }
+    /**
+     * Perform a user login against the configured login webservice
+     *
+     * @param loginOkCallback Method to be executed once the login finishes chorrectly. An object with all the service response data will be passed to this method
+     * @param loginFailCallback Method to be executed once the login finishes incorrectly.
+     */
+    login(loginOkCallback = null, loginFailCallback = null) {
+        const request = new HTTPServicePostRequest(this.loginWebService);
+        request.ignoreGlobalPostParams = true;
+        const encodedCredentials = ConversionUtils.stringToBase64(ConversionUtils.stringToBase64(this.userName) + ',' + ConversionUtils.stringToBase64(this.password));
+        request.parameters = {
+            data: encodedCredentials
+        };
+        request.successCallback = (response) => {
+            if (response !== '') {
+                response = JSON.parse(response);
+                this._isLogged = true;
+                this._token = response.token;
+                this.httpService.setGlobalPostParam('token', response.token);
+                if (loginOkCallback !== null) {
+                    loginOkCallback(response);
+                }
+            }
+            else {
+                this._clearUserAndToken();
+                if (loginFailCallback !== null) {
+                    loginFailCallback();
+                }
+            }
+        };
+        this.httpService.execute(request);
+    }
+    /**
+     * Perform the logout for the currently logged user
+     */
+    logout(logoutOkCallback = null) {
+        const request = new HTTPServicePostRequest('users/logout');
+        request.parameters = {
+            token: this._token
+        };
+        request.successCallback = () => {
+            this._clearUserAndToken();
+            if (logoutOkCallback !== null) {
+                logoutOkCallback();
+            }
+        };
+        this.httpService.execute(request);
+    }
+    _clearUserAndToken() {
+        this.userName = '';
+        this.password = '';
+        this._isLogged = false;
+        this._token = '';
+        if (this.httpService.isGlobalPostParam('token')) {
+            this.httpService.deleteGlobalPostParam('token');
+        }
+    }
+}
+UserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: UserService, deps: [{ token: i1.HTTPService }, { token: i2.LocalizationService }], target: i0.ɵɵFactoryTarget.Injectable });
+UserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: UserService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HTTPService }, { type: i2.LocalizationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.service.js","sourceRoot":"","sources":["../../../../../projects/turbogui-angular/src/main/controller/user.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 { Injectable } from '@angular/core';\r\nimport { ConversionUtils, StringUtils } from 'turbocommons-ts';\r\nimport { HTTPService } from '../controller/http.service';\r\nimport { LocalizationService } from '../controller/localization.service';\r\nimport { HTTPServicePostRequest } from '../controller/httpservice/HTTPServicePostRequest';\r\n\r\n\r\n/**\r\n * Manages the users model and commands\r\n */\r\n@Injectable()\r\nexport class UserService {\r\n\r\n\r\n    /**\r\n     * Path to the web service that performs the user login\r\n     */\r\n    loginWebService = 'users/login';\r\n    \r\n\r\n    /**\r\n     * The username that is currently defined and will be used by the login methods\r\n     */\r\n    userName = '';\r\n\r\n\r\n    /**\r\n     * The password for the user that is currently defined and will be used by the login methods\r\n     */\r\n    password = '';\r\n\r\n\r\n    /**\r\n     * Check public getter for docs\r\n     */\r\n    private _isLogged = false;\r\n    \r\n    \r\n    /**\r\n     * @see token() getter for more info\r\n     */\r\n    private _token = '';\r\n\r\n\r\n    constructor(public httpService: HTTPService,\r\n                public ls: LocalizationService) {\r\n    }\r\n\r\n\r\n    /**\r\n     * Tells if the services contains a non empty username and password specified\r\n     */\r\n    get isUserAndPswDefined(): boolean  {\r\n\r\n        return !StringUtils.isEmpty(this.userName) && !StringUtils.isEmpty(this.password);\r\n    }\r\n\r\n\r\n    /**\r\n     * Tells if exists a user that is currently logged or not\r\n     */\r\n    get isLogged(): boolean {\r\n\r\n        return this._isLogged;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Gives the value for the currently active user authentication token or an empty string if no user logged\r\n     */\r\n    get token() {\r\n\r\n        return this._token;\r\n    }\r\n\r\n\r\n    /**\r\n     * Perform a user login against the configured login webservice\r\n     * \r\n     * @param loginOkCallback Method to be executed once the login finishes chorrectly. An object with all the service response data will be passed to this method\r\n     * @param loginFailCallback Method to be executed once the login finishes incorrectly.\r\n     */\r\n    login(loginOkCallback: null | ((response: any) => void) = null, loginFailCallback: null | (() => void) = null) {\r\n\r\n        const request = new HTTPServicePostRequest(this.loginWebService);\r\n        \r\n        request.ignoreGlobalPostParams = true;\r\n\r\n        const encodedCredentials = ConversionUtils.stringToBase64(\r\n                ConversionUtils.stringToBase64(this.userName) + ',' + ConversionUtils.stringToBase64(this.password));\r\n\r\n        request.parameters = {\r\n            data: encodedCredentials\r\n        };\r\n        \r\n        request.successCallback = (response) => {\r\n        \r\n            if (response !== '') {\r\n\r\n                response = JSON.parse(response);            \r\n\r\n                this._isLogged = true;\r\n                this._token = response.token;\r\n                this.httpService.setGlobalPostParam('token', response.token);\r\n\r\n                if (loginOkCallback !== null) {\r\n\r\n                    loginOkCallback(response);\r\n                }\r\n\r\n            } else {\r\n\r\n                this._clearUserAndToken();\r\n\r\n                if (loginFailCallback !== null) {\r\n\r\n                    loginFailCallback();\r\n                }\r\n            }\r\n        };\r\n\r\n        this.httpService.execute(request);\r\n    }\r\n\r\n\r\n    /**\r\n     * Perform the logout for the currently logged user\r\n     */\r\n    logout(logoutOkCallback: null | (() => void) = null) {\r\n        \r\n        const request = new HTTPServicePostRequest('users/logout');\r\n        \r\n        request.parameters = {\r\n            token: this._token\r\n        };\r\n        \r\n        request.successCallback = () => {\r\n        \r\n            this._clearUserAndToken();\r\n            \r\n            if (logoutOkCallback !== null) {\r\n\r\n                logoutOkCallback();\r\n            }\r\n        };\r\n\r\n        this.httpService.execute(request);\r\n    }\r\n    \r\n    \r\n    private _clearUserAndToken(){\r\n    \r\n        this.userName = '';\r\n        this.password = '';\r\n        this._isLogged = false;\r\n        this._token = '';\r\n        \r\n        if(this.httpService.isGlobalPostParam('token')){\r\n            \r\n            this.httpService.deleteGlobalPostParam('token');\r\n        }    \r\n    }\r\n}\r\n"]}

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

@@ -0,0 +1,113 @@
+/**
+ * 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";
+/**
+ * Manages adding, removing and manipulating the application views
+ */
+export class ViewsService {
+    constructor(componentFactoryResolver) {
+        this.componentFactoryResolver = componentFactoryResolver;
+        /**
+         * See getter method for docs
+         */
+        this._loadedViewClass = null;
+        /**
+         * An instance of the model that is assigned to the currently loaded view
+         */
+        this._loadedViewModel = null;
+        /**
+         * See setter method for docs
+         */
+        this._viewContainerRef = null;
+    }
+    /**
+     * Tells if there's any view currently loaded on the application views container
+     */
+    get isViewLoaded() {
+        return this._loadedViewClass !== null;
+    }
+    /**
+     * Stores a reference to the visual element that will be used as the container for all the views.
+     * This is automatically assigned by the tg-views-container component once it is created.
+     *
+     * @see ViewsContainerComponent for more information
+     */
+    set viewContainerRef(ref) {
+        if (ref !== null && this._viewContainerRef !== null) {
+            throw new Error('Views container already defined. Only one views container element can exist on an application');
+        }
+        this._viewContainerRef = ref;
+    }
+    /**
+     * Create a new view instance with the specified type and add it to the current application views container. Any currently loaded
+     * view will be removed
+     *
+     * Make sure this method is called when all the visual components of the application have been created (ngAfterViewInit)
+     *
+     * @param view The classname for the view that we want to create and add to the views container (must extend View base class).
+     *
+     * @return The instance of the newly added and created view.
+     */
+    pushView(view) {
+        // If a view is already loaded, we will unload it first
+        if (this._loadedViewClass !== null) {
+            // If the loaded view is the same as the specified one, we will do nothing
+            if (this._loadedViewClass === view) {
+                return;
+            }
+            this.popView();
+        }
+        this.verifyViewsContainerExist();
+        const factory = this.componentFactoryResolver.resolveComponentFactory(view);
+        const componentRef = this._viewContainerRef.createComponent(factory);
+        this._loadedViewModel = componentRef.instance.modelClass !== null ? new componentRef.instance.modelClass() : null;
+        componentRef.changeDetectorRef.detectChanges();
+        this._loadedViewClass = view;
+        return componentRef;
+    }
+    /**
+     * Get the model that is instantiated for the currently active view. (A view model only lives while its view is active)
+     * If no view model is assigned to the current view or no view is loaded, an exception will be thrown.
+     *
+     * @return The current view model instance, which must be casted to the appropiate ViewModel extended class
+     */
+    get model() {
+        if (this._loadedViewModel === null) {
+            throw new Error('No active model. Make sure a view is loaded with an assigned model. Do not access the model until view is initialized (for example on ngAfterViewInit)');
+        }
+        return this._loadedViewModel;
+    }
+    /**
+     * Delete the currently loaded view from the views container, and leave it empty.
+     * If no view is currently loaded, this method will do nothing
+     */
+    popView() {
+        this.verifyViewsContainerExist();
+        if (this._loadedViewClass !== null) {
+            this._viewContainerRef.clear();
+        }
+        this._loadedViewClass = null;
+        this._loadedViewModel = null;
+    }
+    /**
+     * Auxiliary method to test if the views container instance is available on the application
+     */
+    verifyViewsContainerExist() {
+        if (this._viewContainerRef === null) {
+            throw new Error('Views container not defined. Please declare a <views-container> element in your application');
+        }
+    }
+}
+ViewsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ViewsService, deps: [{ token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Injectable });
+ViewsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ViewsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ViewsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"views.service.js","sourceRoot":"","sources":["../../../../../projects/turbogui-angular/src/main/controller/views.service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAA0B,UAAU,EAA4B,MAAM,eAAe,CAAC;;AAK7F;;GAEG;AAEH,MAAM,OAAO,YAAY;IAqBrB,YAA6B,wBAAkD;QAAlD,6BAAwB,GAAxB,wBAAwB,CAA0B;QAlB/E;;WAEG;QACK,qBAAgB,GAAsB,IAAI,CAAC;QAGnD;;WAEG;QACK,qBAAgB,GAAqB,IAAI,CAAC;QAGlD;;WAEG;QACK,sBAAiB,GAA4B,IAAI,CAAC;IAK1D,CAAC;IAGD;;OAEG;IACH,IAAI,YAAY;QAEZ,OAAO,IAAI,CAAC,gBAAgB,KAAK,IAAI,CAAC;IAC1C,CAAC;IAGD;;;;;OAKG;IACH,IAAI,gBAAgB,CAAC,GAA4B;QAE7C,IAAI,GAAG,KAAK,IAAI,IAAI,IAAI,CAAC,iBAAiB,KAAK,IAAI,EAAE;YAEjD,MAAM,IAAI,KAAK,CAAC,+FAA+F,CAAC,CAAC;SACpH;QAED,IAAI,CAAC,iBAAiB,GAAG,GAAG,CAAC;IACjC,CAAC;IAGD;;;;;;;;;OASG;IACH,QAAQ,CAAC,IAAgB;QAErB,uDAAuD;QACvD,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE;YAEhC,0EAA0E;YAC1E,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE;gBAEhC,OAAO;aACV;YAED,IAAI,CAAC,OAAO,EAAE,CAAC;SAClB;QAED,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAEjC,MAAM,OAAO,GAAG,IAAI,CAAC,wBAAwB,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;QAE5E,MAAM,YAAY,GAAI,IAAI,CAAC,iBAAsC,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAE3F,IAAI,CAAC,gBAAgB,GAAG,YAAY,CAAC,QAAQ,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC,CAAC,IAAK,YAAY,CAAC,QAAQ,CAAC,UAAkB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QAE3H,YAAY,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;QAE/C,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAE7B,OAAO,YAAY,CAAC;IACxB,CAAC;IAGD;;;;;OAKG;IACH,IAAI,KAAK;QAEL,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE;YAEhC,MAAM,IAAI,KAAK,CAAC,wJAAwJ,CAAC,CAAC;SAC7K;QAED,OAAO,IAAI,CAAC,gBAAgB,CAAC;IACjC,CAAC;IAGD;;;OAGG;IACH,OAAO;QAEH,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAEjC,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE;YAE/B,IAAI,CAAC,iBAAsC,CAAC,KAAK,EAAE,CAAC;SACxD;QAED,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;IACjC,CAAC;IAGD;;OAEG;IACK,yBAAyB;QAE7B,IAAI,IAAI,CAAC,iBAAiB,KAAK,IAAI,EAAE;YAEjC,MAAM,IAAI,KAAK,CAAC,6FAA6F,CAAC,CAAC;SAClH;IACL,CAAC;;yGAxIQ,YAAY;6GAAZ,YAAY;2FAAZ,YAAY;kBADxB,UAAU","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 { Type, ViewContainerRef, Injectable, ComponentFactoryResolver } from '@angular/core';\r\nimport { View } from '../model/classes/View';\r\nimport { ViewModel } from '../model/classes/ViewModel';\r\n\r\n\r\n/**\r\n * Manages adding, removing and manipulating the application views\r\n */\r\n@Injectable()\r\nexport class ViewsService {\r\n\r\n\r\n    /**\r\n     * See getter method for docs\r\n     */\r\n    private _loadedViewClass: Type<View> | null = null;\r\n\r\n\r\n    /**\r\n     * An instance of the model that is assigned to the currently loaded view\r\n     */\r\n    private _loadedViewModel: ViewModel | null = null;\r\n\r\n\r\n    /**\r\n     * See setter method for docs\r\n     */\r\n    private _viewContainerRef: ViewContainerRef | null = null;\r\n\r\n\r\n    constructor(private readonly componentFactoryResolver: ComponentFactoryResolver) {\r\n\r\n    }\r\n\r\n\r\n    /**\r\n     * Tells if there's any view currently loaded on the application views container\r\n     */\r\n    get isViewLoaded() {\r\n\r\n        return this._loadedViewClass !== null;\r\n    }\r\n\r\n\r\n    /**\r\n     * Stores a reference to the visual element that will be used as the container for all the views.\r\n     * This is automatically assigned by the tg-views-container component once it is created.\r\n     *\r\n     * @see ViewsContainerComponent for more information\r\n     */\r\n    set viewContainerRef(ref: ViewContainerRef | null) {\r\n\r\n        if (ref !== null && this._viewContainerRef !== null) {\r\n\r\n            throw new Error('Views container already defined. Only one views container element can exist on an application');\r\n        }\r\n\r\n        this._viewContainerRef = ref;\r\n    }\r\n\r\n\r\n    /**\r\n     * Create a new view instance with the specified type and add it to the current application views container. Any currently loaded \r\n     * view will be removed\r\n     *\r\n     * Make sure this method is called when all the visual components of the application have been created (ngAfterViewInit)\r\n     *\r\n     * @param view The classname for the view that we want to create and add to the views container (must extend View base class).\r\n     *\r\n     * @return The instance of the newly added and created view. \r\n     */\r\n    pushView(view: Type<View>) {\r\n\r\n        // If a view is already loaded, we will unload it first\r\n        if (this._loadedViewClass !== null) {\r\n\r\n            // If the loaded view is the same as the specified one, we will do nothing\r\n            if (this._loadedViewClass === view) {\r\n\r\n                return;\r\n            }\r\n\r\n            this.popView();\r\n        }\r\n\r\n        this.verifyViewsContainerExist();\r\n        \r\n        const factory = this.componentFactoryResolver.resolveComponentFactory(view);\r\n\r\n        const componentRef = (this._viewContainerRef as ViewContainerRef).createComponent(factory);\r\n\r\n        this._loadedViewModel = componentRef.instance.modelClass !== null ? new (componentRef.instance.modelClass as any)() : null;\r\n\r\n        componentRef.changeDetectorRef.detectChanges();\r\n\r\n        this._loadedViewClass = view;\r\n\r\n        return componentRef;\r\n    }\r\n\r\n\r\n    /**\r\n     * Get the model that is instantiated for the currently active view. (A view model only lives while its view is active)\r\n     * If no view model is assigned to the current view or no view is loaded, an exception will be thrown.\r\n     *\r\n     * @return The current view model instance, which must be casted to the appropiate ViewModel extended class\r\n     */\r\n    get model() {\r\n\r\n        if (this._loadedViewModel === null) {\r\n\r\n            throw new Error('No active model. Make sure a view is loaded with an assigned model. Do not access the model until view is initialized (for example on ngAfterViewInit)');\r\n        }\r\n\r\n        return this._loadedViewModel;\r\n    }\r\n\r\n\r\n    /**\r\n     * Delete the currently loaded view from the views container, and leave it empty.\r\n     * If no view is currently loaded, this method will do nothing\r\n     */\r\n    popView() {\r\n\r\n        this.verifyViewsContainerExist();\r\n\r\n        if (this._loadedViewClass !== null) {\r\n\r\n            (this._viewContainerRef as ViewContainerRef).clear();\r\n        }\r\n\r\n        this._loadedViewClass = null;\r\n        this._loadedViewModel = null;\r\n    }\r\n\r\n\r\n    /**\r\n     * Auxiliary method to test if the views container instance is available on the application\r\n     */\r\n    private verifyViewsContainerExist() {\r\n\r\n        if (this._viewContainerRef === null) {\r\n\r\n            throw new Error('Views container not defined. Please declare a <views-container> element in your application');\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2020/main/model/modules/turbogui-angular.module.mjs

@@ -0,0 +1,142 @@
+/**
+ * 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 { NgModule } from '@angular/core';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatInputModule } from '@angular/material/input';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatButtonModule } from '@angular/material/button';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { BusyStateBaseComponent } from '../../view/components/busy-state-base/busy-state-base.component';
+import { DialogService } from '../../controller/dialog.service';
+import { LocalizationService } from '../../controller/localization.service';
+import { HTTPService } from '../../controller/http.service';
+import { NotificationService } from '../../controller/notification.service';
+import { UserService } from '../../controller/user.service';
+import { ViewsService } from '../../controller/views.service';
+import { ViewsContainerComponent } from '../../view/components/views-container/views-container.component';
+import { ButtonImageComponent } from '../../view/components/button-image/button-image.component';
+import { ButtonContainerComponent } from '../../view/components/button-container/button-container.component';
+import { DialogErrorComponent } from '../../view/components/dialog-error/dialog-error.component';
+import { DialogSingleOptionComponent } from '../../view/components/dialog-single-option/dialog-single-option.component';
+import { DialogTwoOptionComponent } from '../../view/components/dialog-two-option/dialog-two-option.component';
+import { DialogSingleSelectionListComponent } from '../../view/components/dialog-single-selection-list/dialog-single-selection-list.component';
+import { DialogMultipleOptionComponent } from '../../view/components/dialog-multiple-option/dialog-multiple-option.component';
+import { BrowserService } from '../../controller/browser.service';
+import { ElementCreatedDirective } from '../../view/directives/ElementCreatedDirective';
+import { ElementDestroyedDirective } from '../../view/directives/ElementDestroyedDirective';
+import { AutoFocusOnDisplayDirective } from '../../view/directives/AutoFocusOnDisplayDirective';
+import { AutoSelectTextOnFocusDirective } from '../../view/directives/AutoSelectTextOnFocusDirective';
+import * as i0 from "@angular/core";
+/**
+ * This file contains the root module that contains all the library declarations and exports.
+ */
+export class TurboGuiAngularModule {
+}
+TurboGuiAngularModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TurboGuiAngularModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TurboGuiAngularModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TurboGuiAngularModule, declarations: [BusyStateBaseComponent,
+        DialogErrorComponent,
+        DialogSingleOptionComponent,
+        DialogTwoOptionComponent,
+        DialogMultipleOptionComponent,
+        DialogSingleSelectionListComponent,
+        ViewsContainerComponent,
+        ButtonImageComponent,
+        ButtonContainerComponent,
+        ElementCreatedDirective,
+        ElementDestroyedDirective,
+        AutoFocusOnDisplayDirective,
+        AutoSelectTextOnFocusDirective], imports: [MatDialogModule,
+        MatSnackBarModule,
+        MatInputModule,
+        MatButtonModule,
+        MatFormFieldModule,
+        BrowserAnimationsModule], exports: [BusyStateBaseComponent,
+        ViewsContainerComponent,
+        ButtonImageComponent,
+        ButtonContainerComponent,
+        DialogErrorComponent,
+        DialogSingleOptionComponent,
+        DialogTwoOptionComponent,
+        DialogMultipleOptionComponent,
+        DialogSingleSelectionListComponent,
+        ElementCreatedDirective,
+        ElementDestroyedDirective,
+        AutoFocusOnDisplayDirective,
+        AutoSelectTextOnFocusDirective] });
+TurboGuiAngularModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TurboGuiAngularModule, providers: [
+        DialogService,
+        LocalizationService,
+        HTTPService,
+        NotificationService,
+        UserService,
+        ViewsService,
+        BrowserService
+    ], imports: [[
+            MatDialogModule,
+            MatSnackBarModule,
+            MatInputModule,
+            MatButtonModule,
+            MatFormFieldModule,
+            BrowserAnimationsModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TurboGuiAngularModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        MatDialogModule,
+                        MatSnackBarModule,
+                        MatInputModule,
+                        MatButtonModule,
+                        MatFormFieldModule,
+                        BrowserAnimationsModule
+                    ],
+                    declarations: [
+                        BusyStateBaseComponent,
+                        DialogErrorComponent,
+                        DialogSingleOptionComponent,
+                        DialogTwoOptionComponent,
+                        DialogMultipleOptionComponent,
+                        DialogSingleSelectionListComponent,
+                        ViewsContainerComponent,
+                        ButtonImageComponent,
+                        ButtonContainerComponent,
+                        ElementCreatedDirective,
+                        ElementDestroyedDirective,
+                        AutoFocusOnDisplayDirective,
+                        AutoSelectTextOnFocusDirective
+                    ],
+                    // Globally available singleton services are added here
+                    providers: [
+                        DialogService,
+                        LocalizationService,
+                        HTTPService,
+                        NotificationService,
+                        UserService,
+                        ViewsService,
+                        BrowserService
+                    ],
+                    exports: [
+                        BusyStateBaseComponent,
+                        ViewsContainerComponent,
+                        ButtonImageComponent,
+                        ButtonContainerComponent,
+                        DialogErrorComponent,
+                        DialogSingleOptionComponent,
+                        DialogTwoOptionComponent,
+                        DialogMultipleOptionComponent,
+                        DialogSingleSelectionListComponent,
+                        ElementCreatedDirective,
+                        ElementDestroyedDirective,
+                        AutoFocusOnDisplayDirective,
+                        AutoSelectTextOnFocusDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"turbogui-angular.module.js","sourceRoot":"","sources":["../../../../../../projects/turbogui-angular/src/main/model/modules/turbogui-angular.module.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TurboGUI is A library that helps with the most common and generic UI elements and functionalities\n *\n * Website : -> http://www.turbogui.org\n * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.\n * License Url : -> http://www.apache.org/licenses/LICENSE-2.0\n * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com\n */\n\nimport { NgModule } from '@angular/core';\nimport { MatDialogModule } from '@angular/material/dialog';\nimport { MatInputModule } from '@angular/material/input';\nimport { MatSnackBarModule } from '@angular/material/snack-bar';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { BrowserAnimationsModule } from '@angular/platform-browser/animations';\nimport { BusyStateBaseComponent } from '../../view/components/busy-state-base/busy-state-base.component';\nimport { DialogService } from '../../controller/dialog.service';\r\nimport { LocalizationService } from '../../controller/localization.service';\r\nimport { HTTPService } from '../../controller/http.service';\r\nimport { NotificationService } from '../../controller/notification.service';\nimport { UserService } from '../../controller/user.service';\nimport { ViewsService } from '../../controller/views.service';\r\nimport { ViewsContainerComponent } from '../../view/components/views-container/views-container.component';\r\nimport { ButtonImageComponent } from '../../view/components/button-image/button-image.component';\nimport { ButtonContainerComponent } from '../../view/components/button-container/button-container.component';\nimport { DialogErrorComponent } from '../../view/components/dialog-error/dialog-error.component';\nimport { DialogSingleOptionComponent } from '../../view/components/dialog-single-option/dialog-single-option.component';\nimport { DialogTwoOptionComponent } from '../../view/components/dialog-two-option/dialog-two-option.component';\nimport { DialogSingleSelectionListComponent } from '../../view/components/dialog-single-selection-list/dialog-single-selection-list.component';\r\nimport { DialogMultipleOptionComponent } from '../../view/components/dialog-multiple-option/dialog-multiple-option.component';\r\nimport { BrowserService } from '../../controller/browser.service';\r\nimport { ElementCreatedDirective } from '../../view/directives/ElementCreatedDirective';\r\nimport { ElementDestroyedDirective } from '../../view/directives/ElementDestroyedDirective';\r\nimport { AutoFocusOnDisplayDirective } from '../../view/directives/AutoFocusOnDisplayDirective';\r\nimport { AutoSelectTextOnFocusDirective } from '../../view/directives/AutoSelectTextOnFocusDirective';\n\n\n/**\n * This file contains the root module that contains all the library declarations and exports.\n */\n@NgModule({\n\n    imports: [\n        MatDialogModule,\n        MatSnackBarModule,\n        MatInputModule,\n        MatButtonModule,\n        MatFormFieldModule,\n        BrowserAnimationsModule\n    ],\n\n    declarations: [\n        BusyStateBaseComponent,\n        DialogErrorComponent,\n        DialogSingleOptionComponent,\n        DialogTwoOptionComponent,\n        DialogMultipleOptionComponent,\n        DialogSingleSelectionListComponent,\n        ViewsContainerComponent,\n        ButtonImageComponent,\n        ButtonContainerComponent,\n        ElementCreatedDirective,\n        ElementDestroyedDirective,\n        AutoFocusOnDisplayDirective,\n        AutoSelectTextOnFocusDirective\n    ],\n\n    // Globally available singleton services are added here\n    providers: [\n        DialogService,\n        LocalizationService,\n        HTTPService,\n        NotificationService,\n        UserService,\n        ViewsService,\n        BrowserService\n    ],\n\n    exports: [\n        BusyStateBaseComponent,\n        ViewsContainerComponent,\n        ButtonImageComponent,\n        ButtonContainerComponent,\n        DialogErrorComponent,\n        DialogSingleOptionComponent,\n        DialogTwoOptionComponent,\n        DialogMultipleOptionComponent,\n        DialogSingleSelectionListComponent,\n        ElementCreatedDirective,\n        ElementDestroyedDirective,\n        AutoFocusOnDisplayDirective,\n        AutoSelectTextOnFocusDirective\n    ]\n})\n\nexport class TurboGuiAngularModule { }\n"]}

package/esm2020/main/view/animations/fade.animation.mjs

@@ -0,0 +1,35 @@
+/**
+ * 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 { trigger, animate, transition, style } from '@angular/animations';
+import * as i0 from "@angular/core";
+/**
+ * Fade animations
+ */
+export class FadeAnimationClass {
+    /**
+     * Get a custom trigger to create fade animations when components are added or removed from the application
+     *
+     * @param triggerName The name for the trigger we want to create
+     * @param enter The time and easing that we want to use for the enter state
+     * @param leave The time and easing that we want to use for the leave state
+     */
+    static getTrigger(triggerName, enter = '1s ease', leave = '0s ease') {
+        return trigger(triggerName, [
+            transition(':enter', [style({ opacity: 0 }), animate(enter)]),
+            transition(':leave', [style({ opacity: 1 }), animate(leave, style({ opacity: 0 }))])
+        ]);
+    }
+}
+FadeAnimationClass.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FadeAnimationClass, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FadeAnimationClass.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FadeAnimationClass });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FadeAnimationClass, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/main/view/components/busy-state-base/busy-state-base.component.mjs

@@ -0,0 +1,38 @@
+/**
+ * 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 { Component, HostBinding } from '@angular/core';
+import { FadeAnimationClass } from '../../animations/fade.animation';
+import * as i0 from "@angular/core";
+/**
+ * This component is used by turboGUI angular library to show the busy state to the user.
+ * It is used to block all the user input and progressively shows a busy cursor to notify that the application
+ * is waiting for something.
+ *
+ * We can (should) override this component with our own one to adapt its visual appearance to our application.
+ * We can then set dialogService.busyStateComponentClass to our component class at the application start to to
+ * override the default one.
+ */
+export class BusyStateBaseComponent {
+    constructor() {
+        /**
+         * This is used to attach the fade animation directly to this component so it fades in and out when created and removed from the app
+         */
+        this.busyStateBaseFade = true;
+    }
+}
+BusyStateBaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: BusyStateBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BusyStateBaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: BusyStateBaseComponent, selector: "tg-busy-state-base", host: { properties: { "@busyStateBaseFade": "this.busyStateBaseFade" } }, ngImport: i0, template: "<div class=\"darkBg\">\r\n\r\n</div>\r\n\r\n<svg width=\"38\" height=\"38\" viewBox=\"0 0 38 38\" xmlns=\"http://www.w3.org/2000/svg\" stroke=\"#fff\">\r\n    <g fill=\"none\" fill-rule=\"evenodd\">\r\n        <g transform=\"translate(1 1)\" stroke-width=\"1\">\r\n            <circle stroke-opacity=\".2\" cx=\"18\" cy=\"18\" r=\"18\"/>\r\n            <path d=\"M36 18c0-9.94-8.06-18-18-18\">\r\n                <animateTransform\r\n                    attributeName=\"transform\"\r\n                    type=\"rotate\"\r\n                    from=\"0 18 18\"\r\n                    to=\"360 18 18\"\r\n                    dur=\"1s\"\r\n                    repeatCount=\"indefinite\"/>\r\n            </path>\r\n        </g>\r\n    </g>\r\n</svg>\r\n", styles: [":host{position:fixed;inset:0;display:flex;justify-content:center;align-items:center;z-index:999999999}.darkBg{position:absolute;cursor:progress;width:100%;height:100%;display:flex;justify-content:center;align-items:center;background-color:#00000096;animation-name:bgfadein;animation-duration:30s;animation-timing-function:ease}svg{z-index:5000;width:40%;height:40%;max-width:130px;max-height:130px;animation-name:loadingfadein;animation-duration:3s;animation-timing-function:ease-in}@keyframes loadingfadein{0%{opacity:0}25%{opacity:0}to{opacity:1}}@keyframes bgfadein{0%{opacity:0}4%{opacity:0}14%{opacity:.2}35%{opacity:.5}to{opacity:1}}\n"], animations: [FadeAnimationClass.getTrigger('busyStateBaseFade', '1s ease', '400ms ease')] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: BusyStateBaseComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tg-busy-state-base', animations: [FadeAnimationClass.getTrigger('busyStateBaseFade', '1s ease', '400ms ease')], template: "<div class=\"darkBg\">\r\n\r\n</div>\r\n\r\n<svg width=\"38\" height=\"38\" viewBox=\"0 0 38 38\" xmlns=\"http://www.w3.org/2000/svg\" stroke=\"#fff\">\r\n    <g fill=\"none\" fill-rule=\"evenodd\">\r\n        <g transform=\"translate(1 1)\" stroke-width=\"1\">\r\n            <circle stroke-opacity=\".2\" cx=\"18\" cy=\"18\" r=\"18\"/>\r\n            <path d=\"M36 18c0-9.94-8.06-18-18-18\">\r\n                <animateTransform\r\n                    attributeName=\"transform\"\r\n                    type=\"rotate\"\r\n                    from=\"0 18 18\"\r\n                    to=\"360 18 18\"\r\n                    dur=\"1s\"\r\n                    repeatCount=\"indefinite\"/>\r\n            </path>\r\n        </g>\r\n    </g>\r\n</svg>\r\n", styles: [":host{position:fixed;inset:0;display:flex;justify-content:center;align-items:center;z-index:999999999}.darkBg{position:absolute;cursor:progress;width:100%;height:100%;display:flex;justify-content:center;align-items:center;background-color:#00000096;animation-name:bgfadein;animation-duration:30s;animation-timing-function:ease}svg{z-index:5000;width:40%;height:40%;max-width:130px;max-height:130px;animation-name:loadingfadein;animation-duration:3s;animation-timing-function:ease-in}@keyframes loadingfadein{0%{opacity:0}25%{opacity:0}to{opacity:1}}@keyframes bgfadein{0%{opacity:0}4%{opacity:0}14%{opacity:.2}35%{opacity:.5}to{opacity:1}}\n"] }]
+        }], propDecorators: { busyStateBaseFade: [{
+                type: HostBinding,
+                args: ['@busyStateBaseFade']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVzeS1zdGF0ZS1iYXNlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R1cmJvZ3VpLWFuZ3VsYXIvc3JjL21haW4vdmlldy9jb21wb25lbnRzL2J1c3ktc3RhdGUtYmFzZS9idXN5LXN0YXRlLWJhc2UuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHVyYm9ndWktYW5ndWxhci9zcmMvbWFpbi92aWV3L2NvbXBvbmVudHMvYnVzeS1zdGF0ZS1iYXNlL2J1c3ktc3RhdGUtYmFzZS5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7OztHQU9HO0FBRUgsT0FBTyxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdkQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0saUNBQWlDLENBQUM7O0FBR3JFOzs7Ozs7OztHQVFHO0FBU0gsTUFBTSxPQUFPLHNCQUFzQjtJQVJuQztRQVdJOztXQUVHO1FBQ2dDLHNCQUFpQixHQUFHLElBQUksQ0FBQztLQUMvRDs7bUhBUFksc0JBQXNCO3VHQUF0QixzQkFBc0Isb0lDOUJuQyxpdkJBb0JBLDZwQkRLYyxDQUFDLGtCQUFrQixDQUFDLFVBQVUsQ0FBQyxtQkFBbUIsRUFBRSxTQUFTLEVBQUUsWUFBWSxDQUFDLENBQUM7MkZBSzlFLHNCQUFzQjtrQkFSbEMsU0FBUzsrQkFDRSxvQkFBb0IsY0FFbEIsQ0FBQyxrQkFBa0IsQ0FBQyxVQUFVLENBQUMsbUJBQW1CLEVBQUUsU0FBUyxFQUFFLFlBQVksQ0FBQyxDQUFDOzhCQVdwRCxpQkFBaUI7c0JBQW5ELFdBQVc7dUJBQUMsb0JBQW9CIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIFR1cmJvR1VJIGlzIEEgbGlicmFyeSB0aGF0IGhlbHBzIHdpdGggdGhlIG1vc3QgY29tbW9uIGFuZCBnZW5lcmljIFVJIGVsZW1lbnRzIGFuZCBmdW5jdGlvbmFsaXRpZXNcclxuICpcclxuICogV2Vic2l0ZSA6IC0+IGh0dHA6Ly93d3cudHVyYm9ndWkub3JnXHJcbiAqIExpY2Vuc2UgOiAtPiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wLiBZb3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXHJcbiAqIExpY2Vuc2UgVXJsIDogLT4gaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXHJcbiAqIENvcHlSaWdodCA6IC0+IENvcHlyaWdodCAyMDE4IEVkZXJ0b25lIEFkdmFuZGVkIFNvbHV0aW9ucy4gaHR0cHM6Ly93d3cuZWRlcnRvbmUuY29tXHJcbiAqL1xyXG5cclxuaW1wb3J0IHsgQ29tcG9uZW50LCBIb3N0QmluZGluZyB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBGYWRlQW5pbWF0aW9uQ2xhc3MgfSBmcm9tICcuLi8uLi9hbmltYXRpb25zL2ZhZGUuYW5pbWF0aW9uJztcclxuXHJcblxyXG4vKipcclxuICogVGhpcyBjb21wb25lbnQgaXMgdXNlZCBieSB0dXJib0dVSSBhbmd1bGFyIGxpYnJhcnkgdG8gc2hvdyB0aGUgYnVzeSBzdGF0ZSB0byB0aGUgdXNlci5cclxuICogSXQgaXMgdXNlZCB0byBibG9jayBhbGwgdGhlIHVzZXIgaW5wdXQgYW5kIHByb2dyZXNzaXZlbHkgc2hvd3MgYSBidXN5IGN1cnNvciB0byBub3RpZnkgdGhhdCB0aGUgYXBwbGljYXRpb25cclxuICogaXMgd2FpdGluZyBmb3Igc29tZXRoaW5nLlxyXG4gKlxyXG4gKiBXZSBjYW4gKHNob3VsZCkgb3ZlcnJpZGUgdGhpcyBjb21wb25lbnQgd2l0aCBvdXIgb3duIG9uZSB0byBhZGFwdCBpdHMgdmlzdWFsIGFwcGVhcmFuY2UgdG8gb3VyIGFwcGxpY2F0aW9uLlxyXG4gKiBXZSBjYW4gdGhlbiBzZXQgZGlhbG9nU2VydmljZS5idXN5U3RhdGVDb21wb25lbnRDbGFzcyB0byBvdXIgY29tcG9uZW50IGNsYXNzIGF0IHRoZSBhcHBsaWNhdGlvbiBzdGFydCB0byB0b1xyXG4gKiBvdmVycmlkZSB0aGUgZGVmYXVsdCBvbmUuXHJcbiAqL1xyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ3RnLWJ1c3ktc3RhdGUtYmFzZScsXHJcbiAgdGVtcGxhdGVVcmw6ICcuL2J1c3ktc3RhdGUtYmFzZS5jb21wb25lbnQuaHRtbCcsXHJcbiAgYW5pbWF0aW9uczogW0ZhZGVBbmltYXRpb25DbGFzcy5nZXRUcmlnZ2VyKCdidXN5U3RhdGVCYXNlRmFkZScsICcxcyBlYXNlJywgJzQwMG1zIGVhc2UnKV0sXHJcbiAgc3R5bGVVcmxzOiBbJy4vYnVzeS1zdGF0ZS1iYXNlLmNvbXBvbmVudC5zY3NzJ11cclxufSlcclxuXHJcblxyXG5leHBvcnQgY2xhc3MgQnVzeVN0YXRlQmFzZUNvbXBvbmVudCB7XHJcblxyXG5cclxuICAgIC8qKlxyXG4gICAgICogVGhpcyBpcyB1c2VkIHRvIGF0dGFjaCB0aGUgZmFkZSBhbmltYXRpb24gZGlyZWN0bHkgdG8gdGhpcyBjb21wb25lbnQgc28gaXQgZmFkZXMgaW4gYW5kIG91dCB3aGVuIGNyZWF0ZWQgYW5kIHJlbW92ZWQgZnJvbSB0aGUgYXBwXHJcbiAgICAgKi9cclxuICAgIEBIb3N0QmluZGluZygnQGJ1c3lTdGF0ZUJhc2VGYWRlJykgYnVzeVN0YXRlQmFzZUZhZGUgPSB0cnVlO1xyXG59XHJcbiIsIjxkaXYgY2xhc3M9XCJkYXJrQmdcIj5cclxuXHJcbjwvZGl2PlxyXG5cclxuPHN2ZyB3aWR0aD1cIjM4XCIgaGVpZ2h0PVwiMzhcIiB2aWV3Qm94PVwiMCAwIDM4IDM4XCIgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHN0cm9rZT1cIiNmZmZcIj5cclxuICAgIDxnIGZpbGw9XCJub25lXCIgZmlsbC1ydWxlPVwiZXZlbm9kZFwiPlxyXG4gICAgICAgIDxnIHRyYW5zZm9ybT1cInRyYW5zbGF0ZSgxIDEpXCIgc3Ryb2tlLXdpZHRoPVwiMVwiPlxyXG4gICAgICAgICAgICA8Y2lyY2xlIHN0cm9rZS1vcGFjaXR5PVwiLjJcIiBjeD1cIjE4XCIgY3k9XCIxOFwiIHI9XCIxOFwiLz5cclxuICAgICAgICAgICAgPHBhdGggZD1cIk0zNiAxOGMwLTkuOTQtOC4wNi0xOC0xOC0xOFwiPlxyXG4gICAgICAgICAgICAgICAgPGFuaW1hdGVUcmFuc2Zvcm1cclxuICAgICAgICAgICAgICAgICAgICBhdHRyaWJ1dGVOYW1lPVwidHJhbnNmb3JtXCJcclxuICAgICAgICAgICAgICAgICAgICB0eXBlPVwicm90YXRlXCJcclxuICAgICAgICAgICAgICAgICAgICBmcm9tPVwiMCAxOCAxOFwiXHJcbiAgICAgICAgICAgICAgICAgICAgdG89XCIzNjAgMTggMThcIlxyXG4gICAgICAgICAgICAgICAgICAgIGR1cj1cIjFzXCJcclxuICAgICAgICAgICAgICAgICAgICByZXBlYXRDb3VudD1cImluZGVmaW5pdGVcIi8+XHJcbiAgICAgICAgICAgIDwvcGF0aD5cclxuICAgICAgICA8L2c+XHJcbiAgICA8L2c+XHJcbjwvc3ZnPlxyXG4iXX0=