@falcon-ng/tailwind 0.0.2 → 0.0.4

package/esm2020/lib/service/appsetting.service.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import { Subject, from } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./logger.service";
+export class AppSettingService {
+    constructor(http, logger) {
+        this.http = http;
+        this.logger = logger;
+        this.initialized = false;
+        this.isServiceReady = new Subject();
+        this.listeners = {};
+        this.eventsSubject = new Subject();
+        this.events = from(this.eventsSubject);
+        this.events.subscribe(({ name, args }) => {
+            if (this.listeners[name]) {
+                for (let listener of this.listeners[name]) {
+                    listener(...args);
+                }
+            }
+        });
+    }
+    async load() {
+        if (this.initialized)
+            return;
+        let data = await this.http.get('assets/appsetting.json').toPromise();
+        this.appSettings = data;
+        this.initialized = true;
+        this.isServiceReady.next(this.initialized);
+        this.logger.info("[AppSettingService] load --> isServiceReady", this.initialized);
+    }
+    on(name, listener) {
+        if (!this.listeners[name]) {
+            this.listeners[name] = [];
+        }
+        this.listeners[name].push(listener);
+    }
+    getAppsettingValue() {
+        return this.appSettings ? this.appSettings : null;
+    }
+}
+AppSettingService.APP_SETTINGS_LOADED = "APP_SETTINGS_LOADED";
+AppSettingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: AppSettingService, deps: [{ token: i1.HttpClient }, { token: i2.LoggerService }], target: i0.ɵɵFactoryTarget.Injectable });
+AppSettingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: AppSettingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: AppSettingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.LoggerService }]; } });
+export function appSettingsFactory(appSettings) {
+    return async () => await appSettings.load();
+}
+;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/service/http/generic-http-client.mjs

@@ -0,0 +1,197 @@
+import { HttpRequest, HttpEventType } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../model/environments";
+import * as i3 from "@angular/material/snack-bar";
+import * as i4 from "../logger.service";
+export class GenericHttpClient {
+    constructor(httpClient, environment, _snackBar, logger) {
+        this.httpClient = httpClient;
+        this.environment = environment;
+        this._snackBar = _snackBar;
+        this.logger = logger;
+        this.snackBarViewModel = {};
+        this.isHttpError = false;
+    }
+    /**
+    * @description
+    * Generic Http GET method to Get the response and bind to the view model
+    * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+    * @param {IRequestOptions} options options of the request like headers, body, etc.
+    * @returns {Observable<T>}
+    * @usageNotes
+    * The following snippet shows how to use this method
+    * ```ts
+    *    this.genericHttpService.Get("get_url").subscribe(data => {
+    *        console.log('success');
+    *      }, error => {
+    *      console.log(error);
+    *      });
+    * ```
+  */
+    get(destinationUrl, options) {
+        return this.request("GET" /* HttpMethod.Get */, destinationUrl, options);
+    }
+    /**
+      * @description
+      * Generic Http post method to post the view model and bind the return view model
+      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+      * @param {IRequestOptions} options options of the request like headers, body, etc.
+      * @returns {Observable<T>}
+      * @usageNotes
+      * The following snippet shows how to use this method
+      * ```ts
+      *    this.genericHttpClientService.Post(post-url,post-view-model).subscribe(item => {
+      *        console.log(item);
+      *      },
+      *      err => {
+      *        console.log(err);
+      *      });
+      * ```
+    */
+    post(destinationUrl, options) {
+        return this.request("POST" /* HttpMethod.Post */, destinationUrl, options);
+    }
+    /**
+      * @description
+      * Generic Http Put method to post the view model and bind the return view model
+      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+      * @param {IRequestOptions} options options of the request like headers, body, etc.
+      * @returns {Observable<T>}
+      * @usageNotes
+      * The following snippet shows how to use this method
+      * ```ts
+      *    this.genericHttpClientService.Put(post-url, post-view-model).subscribe(item => {
+      *        console.log(item);
+      *      },
+      *      err => {
+      *        console.log(err);
+      *      });
+      * ```
+    */
+    put(destinationUrl, options) {
+        return this.request("PUT" /* HttpMethod.Put */, destinationUrl, options);
+    }
+    /**
+        * @description
+        * Generic Http post method to post the view model and bind the return view model
+        * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+        * @param {IRequestOptions} options options of the request like headers, body, etc.
+        * @returns {Observable<T>}
+        * @usageNotes
+        * The following snippet shows how to use this method
+        * ```ts
+        *    this.genericHttpClientService.Post(post-url,post-view-model).subscribe(item => {
+        *        console.log(item);
+        *      },
+        *      err => {
+        *        console.log(err);
+        *      });
+        * ```
+      */
+    patch(destinationUrl, options) {
+        return this.request("PATCH" /* HttpMethod.Patch */, destinationUrl, options);
+    }
+    /**
+      * @description
+      * Generic Http Delete method to Delete the item and bind the return view model
+      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+      * @param {IRequestOptions} options options of the request like headers, body, etc.
+      * @returns {Observable<T>}
+      * @usageNotes
+      * The following snippet shows how to use this method
+      * ```ts
+      *    this.genericHttpClientService.Delete(this.deleteUserUrl).subscribe(item => {
+      *         console.log('success');
+      *      }, error => {
+      *        console.log(error);
+      *      });
+      * ```
+    */
+    delete(destinationUrl, options) {
+        return this.request("DELETE" /* HttpMethod.Delete */, destinationUrl, options);
+    }
+    /**
+        * @description
+        * Http request method to accept different method type and params
+        * @param {string} method Http methods - GET, POST, PUT, DELETE.
+        * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+        * @param {IRequestOptions} options options of the request like headers, body, etc.
+        * @returns {Observable<T>}
+        * @usageNotes
+        * The following snippet shows how to use this method
+        * ```ts
+        *    this.request<T>(HttpMethod.Delete, destinationUrl, options);
+        * ```
+      */
+    request(method, url, options) {
+        return Observable.create((observer) => {
+            let destinationUrl = '';
+            if (this.environment.baseUrl != undefined)
+                destinationUrl = (this.environment.baseUrl) + url;
+            else
+                destinationUrl = url;
+            this.httpClient.request(new HttpRequest(method, destinationUrl, options)).subscribe((response) => {
+                const responsTye = response;
+                switch (responsTye.type) {
+                    case HttpEventType.Sent:
+                        this.logger.info('Http Client : Sent ->', 'Request sent!');
+                        break;
+                    case HttpEventType.ResponseHeader:
+                        this.logger.info('Http Client : ResponseHeader ->', 'Response header received!');
+                        break;
+                    case HttpEventType.DownloadProgress:
+                        const kbLoaded = Math.round(responsTye.loaded / 1024);
+                        this.logger.info('Http Client : DownloadProgress ->', `Download in progress! ${kbLoaded}Kb loaded`);
+                        break;
+                    case HttpEventType.Response:
+                        observer.next(response.body);
+                        this.logger.info('Http Client : Response -> 😺 Done!', responsTye.body);
+                }
+            }, (error) => {
+                switch (error.status) {
+                    case 403 /* HttpStatusCode.Forbidden */:
+                        // observer.complete();
+                        this.snackBarViewModel.messageText = 'Access to the requested resource is forbidden.';
+                        this.snackBarViewModel.actionText = 'Forbidden';
+                        this.isHttpError = true;
+                        break;
+                    case 400 /* HttpStatusCode.BadRequest */:
+                        this.snackBarViewModel.messageText = 'Server cannot or will not process the request.';
+                        this.snackBarViewModel.actionText = 'Bad Request';
+                        this.isHttpError = true;
+                        break;
+                    case 401 /* HttpStatusCode.Unauthorized */:
+                        this.snackBarViewModel.messageText = 'Request has not been applied because it lacks valid authentication credentials.';
+                        this.snackBarViewModel.actionText = 'Unauthorized';
+                        this.isHttpError = true;
+                        break;
+                    case 500 /* HttpStatusCode.InternalServerError */:
+                        this.snackBarViewModel.messageText = 'Server encountered an unexpected condition.';
+                        this.snackBarViewModel.actionText = 'Internal server error';
+                        this.isHttpError = true;
+                        break;
+                    case 0:
+                        this.snackBarViewModel.messageText = 'Not connected to the service.';
+                        this.snackBarViewModel.actionText = 'Service not available';
+                        this.isHttpError = true;
+                        break;
+                }
+                observer.error(error);
+                if ((this.environment.snackBarEnable != undefined && this.environment.snackBarEnable) && this.isHttpError)
+                    this._snackBar.open(this.snackBarViewModel.messageText, this.snackBarViewModel.actionText);
+            });
+        });
+    }
+}
+GenericHttpClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: GenericHttpClient, deps: [{ token: i1.HttpClient }, { token: i2.EnvironmentViewModel }, { token: i3.MatSnackBar }, { token: i4.LoggerService }], target: i0.ɵɵFactoryTarget.Injectable });
+GenericHttpClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: GenericHttpClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: GenericHttpClient, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EnvironmentViewModel }, { type: i3.MatSnackBar }, { type: i4.LoggerService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generic-http-client.js","sourceRoot":"","sources":["../../../../../../../projects/falcon-ng/tailwind/src/lib/service/http/generic-http-client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  HttpClient,\n  HttpRequest,\n  HttpEventType,\n  HttpEvent,\n  HttpStatusCode\n} from '@angular/common/http';\nimport { Observable, from } from 'rxjs';\nimport { IGenericHttpClient } from './igeneric-http-client';\nimport { Injectable } from '@angular/core';\nimport {IRequestOptions, SnackbarModel} from '../../model/interface';\nimport { LoggerService } from '../logger.service';\nimport {EnvironmentViewModel} from \"../../model/environments\";\nimport {HttpMethod} from \"../../model/enum\";\nimport {MatSnackBar} from \"@angular/material/snack-bar\";\n@Injectable({\n  providedIn: 'root'\n})\nexport class GenericHttpClient<T> implements IGenericHttpClient<T>{\n  private snackBarViewModel: SnackbarModel = {} as SnackbarModel;\n  private isHttpError: boolean = false;\n\n  constructor(private httpClient: HttpClient, private environment: EnvironmentViewModel,\n    private _snackBar: MatSnackBar, private logger: LoggerService) { }\n\n\n  /**\n  * @description\n  * Generic Http GET method to Get the response and bind to the view model\n  * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n  * @param {IRequestOptions} options options of the request like headers, body, etc.\n  * @returns {Observable<T>}\n  * @usageNotes\n  * The following snippet shows how to use this method\n  * ```ts\n  *    this.genericHttpService.Get(\"get_url\").subscribe(data => {\n  *        console.log('success');\n  *      }, error => {\n  *      console.log(error);\n  *      });\n  * ```\n*/\n  public get(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Get, destinationUrl, options);\n  }\n\n  /**\n    * @description\n    * Generic Http post method to post the view model and bind the return view model\n    * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n    * @param {IRequestOptions} options options of the request like headers, body, etc.\n    * @returns {Observable<T>}\n    * @usageNotes\n    * The following snippet shows how to use this method\n    * ```ts\n    *    this.genericHttpClientService.Post(post-url,post-view-model).subscribe(item => {\n    *        console.log(item);\n    *      },\n    *      err => {\n    *        console.log(err);\n    *      });\n    * ```\n  */\n  public post(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Post, destinationUrl, options);\n  }\n\n  /**\n    * @description\n    * Generic Http Put method to post the view model and bind the return view model\n    * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n    * @param {IRequestOptions} options options of the request like headers, body, etc.\n    * @returns {Observable<T>}\n    * @usageNotes\n    * The following snippet shows how to use this method\n    * ```ts\n    *    this.genericHttpClientService.Put(post-url, post-view-model).subscribe(item => {\n    *        console.log(item);\n    *      },\n    *      err => {\n    *        console.log(err);\n    *      });\n    * ```\n  */\n  public put(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Put, destinationUrl, options);\n  }\n\n  /**\n      * @description\n      * Generic Http post method to post the view model and bind the return view model\n      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n      * @param {IRequestOptions} options options of the request like headers, body, etc.\n      * @returns {Observable<T>}\n      * @usageNotes\n      * The following snippet shows how to use this method\n      * ```ts\n      *    this.genericHttpClientService.Post(post-url,post-view-model).subscribe(item => {\n      *        console.log(item);\n      *      },\n      *      err => {\n      *        console.log(err);\n      *      });\n      * ```\n    */\n  public patch(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Patch, destinationUrl, options);\n  }\n\n  /**\n    * @description\n    * Generic Http Delete method to Delete the item and bind the return view model\n    * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n    * @param {IRequestOptions} options options of the request like headers, body, etc.\n    * @returns {Observable<T>}\n    * @usageNotes\n    * The following snippet shows how to use this method\n    * ```ts\n    *    this.genericHttpClientService.Delete(this.deleteUserUrl).subscribe(item => {\n    *         console.log('success');\n    *      }, error => {\n    *        console.log(error);\n    *      });\n    * ```\n  */\n  public delete(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Delete, destinationUrl, options);\n  }\n  \n  /**\n      * @description\n      * Http request method to accept different method type and params\n      * @param {string} method Http methods - GET, POST, PUT, DELETE.\n      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n      * @param {IRequestOptions} options options of the request like headers, body, etc.\n      * @returns {Observable<T>}\n      * @usageNotes\n      * The following snippet shows how to use this method\n      * ```ts\n      *    this.request<T>(HttpMethod.Delete, destinationUrl, options);\n      * ```\n    */\n  private request<T>(method: string, url: string, options?: IRequestOptions): Observable<T> {\n    return Observable.create((observer: any) => {\n      let destinationUrl = '';\n      if (this.environment.baseUrl != undefined)\n        destinationUrl = (this.environment.baseUrl) + url\n      else\n        destinationUrl = url\n      this.httpClient.request<T>(new HttpRequest(method, destinationUrl, options)).subscribe(\n        (response: any) => {\n          const responsTye = response as HttpEvent<any>\n          switch (responsTye.type) {\n            case HttpEventType.Sent:\n              this.logger.info('Http Client : Sent ->', 'Request sent!');\n              break;\n            case HttpEventType.ResponseHeader:\n              this.logger.info('Http Client : ResponseHeader ->', 'Response header received!');\n              break;\n            case HttpEventType.DownloadProgress:\n              const kbLoaded = Math.round(responsTye.loaded / 1024);\n              this.logger.info('Http Client : DownloadProgress ->', `Download in progress! ${kbLoaded}Kb loaded`);\n              break;\n            case HttpEventType.Response:\n              observer.next(response.body);\n              this.logger.info('Http Client : Response -> 😺 Done!', responsTye.body);\n          }\n        },\n        (error) => {\n          switch (error.status) {\n            case HttpStatusCode.Forbidden:\n              // observer.complete();\n              this.snackBarViewModel.messageText = 'Access to the requested resource is forbidden.';\n              this.snackBarViewModel.actionText = 'Forbidden';\n              this.isHttpError = true;\n              break;\n            case HttpStatusCode.BadRequest:\n              this.snackBarViewModel.messageText = 'Server cannot or will not process the request.';\n              this.snackBarViewModel.actionText = 'Bad Request';\n              this.isHttpError = true;\n              break;\n            case HttpStatusCode.Unauthorized:\n              this.snackBarViewModel.messageText = 'Request has not been applied because it lacks valid authentication credentials.';\n              this.snackBarViewModel.actionText = 'Unauthorized';\n              this.isHttpError = true;\n              break;\n            case HttpStatusCode.InternalServerError:\n              this.snackBarViewModel.messageText = 'Server encountered an unexpected condition.';\n              this.snackBarViewModel.actionText = 'Internal server error';\n              this.isHttpError = true;\n              break;\n            case 0:\n              this.snackBarViewModel.messageText = 'Not connected to the service.';\n              this.snackBarViewModel.actionText = 'Service not available';\n              this.isHttpError = true;\n              break;\n          }\n          observer.error(error);\n          if ((this.environment.snackBarEnable != undefined && this.environment.snackBarEnable) && this.isHttpError)\n            this._snackBar.open(this.snackBarViewModel.messageText, this.snackBarViewModel.actionText);\n        }\n      );\n    });\n  }\n}\n"]}

package/esm2020/lib/service/http/igeneric-http-client.mjs

@@ -0,0 +1,10 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class IGenericHttpClient {
+}
+IGenericHttpClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: IGenericHttpClient, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+IGenericHttpClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: IGenericHttpClient });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: IGenericHttpClient, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/service/logger.service.mjs

@@ -0,0 +1,78 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LoggerService {
+    constructor() {
+        this.initialized = false;
+        this._level = "Warnings" /* LoggingLevel.Warnings */;
+    }
+    async initialize(appSettings) {
+        if (this.initialized)
+            return;
+        this._level = appSettings.loggingLevel;
+        this.initialized = true;
+    }
+    log(message, level = "Warnings" /* LoggingLevel.Warnings */, ...optionalParams) {
+        if (this.shouldLog(level)) {
+            switch (level) {
+                case "Errors" /* LoggingLevel.Errors */:
+                    console.error(message, optionalParams);
+                    break;
+                case "Warnings" /* LoggingLevel.Warnings */:
+                    console.warn(message, optionalParams);
+                    break;
+                case "Info" /* LoggingLevel.Info */:
+                    console.info(message, optionalParams);
+                    break;
+                default:
+                    console.debug(message, optionalParams);
+            }
+        }
+    }
+    shouldLog(level) {
+        if (this._level === "None" /* LoggingLevel.None */) {
+            return false;
+        }
+        else if (this._level === "Errors" /* LoggingLevel.Errors */) {
+            return level === "Errors" /* LoggingLevel.Errors */;
+        }
+        else if (this._level === "Warnings" /* LoggingLevel.Warnings */) {
+            return level === "Errors" /* LoggingLevel.Errors */ || level === "Warnings" /* LoggingLevel.Warnings */;
+        }
+        else if (this._level === "Info" /* LoggingLevel.Info */) {
+            return level === "Errors" /* LoggingLevel.Errors */ || level === "Warnings" /* LoggingLevel.Warnings */ || level === "Info" /* LoggingLevel.Info */;
+        }
+        else {
+            return true;
+        }
+    }
+    error(message, ...optionalParams) {
+        this.log(message, "Errors" /* LoggingLevel.Errors */, optionalParams);
+    }
+    warning(message, ...optionalParams) {
+        this.log(message, "Warnings" /* LoggingLevel.Warnings */, optionalParams);
+    }
+    info(message, ...optionalParams) {
+        this.log(message, "Info" /* LoggingLevel.Info */, optionalParams);
+    }
+    verbose(message, ...optionalParams) {
+        this.log(message, "Verbose" /* LoggingLevel.Verbose */, optionalParams);
+    }
+}
+LoggerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: LoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LoggerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: LoggerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: LoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+export function loggerServiceFactory(loggerService, appSettings) {
+    return async () => {
+        appSettings.isServiceReady.subscribe(item => {
+            if (item)
+                loggerService.initialize(appSettings.getAppsettingValue());
+        });
+    };
+}
+;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/service/open-id/TokenHelperService.mjs

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TokenHelperService {
+    constructor() { }
+    getTokenExpirationDate(dataIdToken) {
+        if (!dataIdToken.hasOwnProperty('exp')) {
+            return new Date();
+        }
+        const date = new Date(0); // The 0 here is the key, which sets the date to the epoch
+        date.setUTCSeconds(dataIdToken.exp);
+        return date;
+    }
+    getPayloadFromToken(token, encode) {
+        let data = {};
+        if (typeof token !== 'undefined') {
+            const encoded = token.split('.')[1];
+            if (encode) {
+                return encoded;
+            }
+            data = JSON.parse(this.urlBase64Decode(encoded));
+        }
+        return data;
+    }
+    getHeaderFromToken(token, encode) {
+        let data = {};
+        if (typeof token !== 'undefined') {
+            const encoded = token.split('.')[0];
+            if (encode) {
+                return encoded;
+            }
+            data = JSON.parse(this.urlBase64Decode(encoded));
+        }
+        return data;
+    }
+    getSignatureFromToken(token, encode) {
+        let data = {};
+        if (typeof token !== 'undefined') {
+            const encoded = token.split('.')[2];
+            if (encode) {
+                return encoded;
+            }
+            data = JSON.parse(this.urlBase64Decode(encoded));
+        }
+        return data;
+    }
+    urlBase64Decode(str) {
+        let output = str.replace('-', '+').replace('_', '/');
+        switch (output.length % 4) {
+            case 0:
+                break;
+            case 2:
+                output += '==';
+                break;
+            case 3:
+                output += '=';
+                break;
+            default:
+                throw Error('Illegal base64url string!');
+        }
+        return window.atob(output);
+    }
+}
+TokenHelperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: TokenHelperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TokenHelperService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: TokenHelperService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: TokenHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/service/open-id/auth-guard.service.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.service";
+export class AuthGuardService {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    canActivate(route, state) {
+        return new Promise(resolve => {
+            this.authService.isServiceReady().then(() => {
+                if (this.authService.isLoggedIn()) {
+                    resolve(true);
+                }
+                else {
+                    this.authService.startAuthentication(state.url);
+                    resolve(false);
+                }
+            });
+        });
+    }
+}
+AuthGuardService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: AuthGuardService, deps: [{ token: i1.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthGuardService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: AuthGuardService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: AuthGuardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC1ndWFyZC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZmFsY29uLW5nL3RhaWx3aW5kL3NyYy9saWIvc2VydmljZS9vcGVuLWlkL2F1dGgtZ3VhcmQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFRM0MsTUFBTSxPQUFPLGdCQUFnQjtJQUUzQixZQUFvQixXQUF5QjtRQUF6QixnQkFBVyxHQUFYLFdBQVcsQ0FBYztJQUFJLENBQUM7SUFFbEQsV0FBVyxDQUFDLEtBQTZCLEVBQUUsS0FBMEI7UUFDbkUsT0FBTyxJQUFJLE9BQU8sQ0FBVSxPQUFPLENBQUMsRUFBRTtZQUNwQyxJQUFJLENBQUMsV0FBVyxDQUFDLGNBQWMsRUFBRSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUU7Z0JBQzFDLElBQUksSUFBSSxDQUFDLFdBQVcsQ0FBQyxVQUFVLEVBQUUsRUFBRTtvQkFDakMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO2lCQUNmO3FCQUFNO29CQUNMLElBQUksQ0FBQyxXQUFXLENBQUMsbUJBQW1CLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO29CQUNoRCxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7aUJBQ2hCO1lBQ0gsQ0FBQyxDQUFDLENBQUE7UUFDSixDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7OzZHQWZVLGdCQUFnQjtpSEFBaEIsZ0JBQWdCLGNBRmYsTUFBTTsyRkFFUCxnQkFBZ0I7a0JBSDVCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQXV0aFNlcnZpY2UgfSBmcm9tICcuL2F1dGguc2VydmljZSc7XG5pbXBvcnQgeyBDYW5BY3RpdmF0ZSwgUm91dGVyU3RhdGVTbmFwc2hvdCwgQWN0aXZhdGVkUm91dGVTbmFwc2hvdCB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIEF1dGhHdWFyZFNlcnZpY2UgaW1wbGVtZW50cyBDYW5BY3RpdmF0ZXtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGF1dGhTZXJ2aWNlIDogQXV0aFNlcnZpY2UpIHsgfVxuXG4gIGNhbkFjdGl2YXRlKHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBzdGF0ZTogUm91dGVyU3RhdGVTbmFwc2hvdCkgOiBib29sZWFuIHwgT2JzZXJ2YWJsZTxib29sZWFuPiB8IFByb21pc2U8Ym9vbGVhbj4ge1xuICAgIHJldHVybiBuZXcgUHJvbWlzZTxib29sZWFuPihyZXNvbHZlID0+IHtcbiAgICAgIHRoaXMuYXV0aFNlcnZpY2UuaXNTZXJ2aWNlUmVhZHkoKS50aGVuKCgpID0+IHtcbiAgICAgICAgaWYgKHRoaXMuYXV0aFNlcnZpY2UuaXNMb2dnZWRJbigpKSB7XG4gICAgICAgICAgcmVzb2x2ZSh0cnVlKTtcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICB0aGlzLmF1dGhTZXJ2aWNlLnN0YXJ0QXV0aGVudGljYXRpb24oc3RhdGUudXJsKTtcbiAgICAgICAgICByZXNvbHZlKGZhbHNlKTtcbiAgICAgICAgfVxuICAgICAgfSlcbiAgICB9KTtcbiAgfVxufVxuIl19