@falcon-ng/tailwind 0.0.2 → 0.0.3

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,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

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

@@ -0,0 +1,154 @@
+import { Injectable } from '@angular/core';
+import { UserManager } from 'oidc-client';
+import * as i0 from "@angular/core";
+import * as i1 from "../logger.service";
+import * as i2 from "./TokenHelperService";
+export class AuthService {
+    constructor(logger, tokenHelperService) {
+        this.logger = logger;
+        this.tokenHelperService = tokenHelperService;
+        this.initialized = false;
+        this.signingOut = false;
+    }
+    async initialize(environment) {
+        if (this.initialized)
+            return;
+        this.settings = this.getClientSettings(environment);
+        this.userManager = new UserManager(this.settings);
+        this.userManager.events.addUserLoaded(user => {
+            this.user = user;
+        });
+        this.userManager.events.addAccessTokenExpiring(() => {
+            this.logger.info("IdSvr token expiring " + new Date().toLocaleString());
+        });
+        this.userManager.events.addAccessTokenExpired(() => {
+            this.logger.info("IdSvr token expired " + new Date().toLocaleString());
+            this.logout(false);
+        });
+        this.userManager.events.addSilentRenewError(e => {
+            this.logger.error("IdSvr silent renew error " + e.message + new Date().toLocaleString());
+            this.logout(false);
+        });
+        this.userManager.events.addUserLoaded(user => {
+            this.logger.info("IdSvr user session is ready " + new Date().toLocaleString());
+            this.accessToken = this.tokenHelperService.getPayloadFromToken(user.access_token, false);
+            this.user = user;
+        });
+        this.userManager.events.addUserUnloaded(() => {
+            this.logger.info("IdSvr user session has ended " + new Date().toLocaleString());
+            if (!this.signingOut) {
+                this.startAuthentication(window.location.pathname + window.location.search);
+            }
+        });
+        this.userManager.events.addUserSignedOut(() => {
+            this.logger.info("IdSvr user signed out " + new Date().toLocaleString());
+            this.logout(false);
+        });
+        this.user = await this.userManager.getUser();
+        this.initialized = true;
+    }
+    isLoggedIn() {
+        return this.user != null && !this.user.expired;
+    }
+    getUser() {
+        return this.userManager.getUser();
+    }
+    getProfile() {
+        return this.user.profile;
+    }
+    getClaims() {
+        return this.user.profile;
+    }
+    getAuthorizationHeaderValue() {
+        if (this.user != null)
+            return `${this.user.token_type} ${this.user.access_token}`;
+        return '';
+    }
+    getAccessToken() {
+        return this.accessToken || this.tokenHelperService.getPayloadFromToken(this.user.access_token, false);
+        ;
+    }
+    async startAuthentication(returnUrl) {
+        this.logger.info("[AuthService] startAuthentication", returnUrl);
+        await this.userManager.clearStaleState();
+        await this.userManager.signinRedirect({ data: { returnUrl: returnUrl } }).catch(err => {
+            //this.$log.debug("IdSvr sign in failed", err);
+            return err;
+        });
+    }
+    async completeAuthentication() {
+        this.logger.info("[AuthService] completeAuthentication");
+        let user = await new Promise((resolve, reject) => {
+            this.userManager.signinRedirectCallback().then(user => {
+                resolve(user);
+            }).catch(error => {
+                reject(error);
+            });
+        });
+        this.user = user;
+        return this.user;
+    }
+    login() {
+        return this.userManager.signinRedirect();
+    }
+    renewToken() {
+        return this.userManager.signinSilent();
+    }
+    logout(signoutRedirect) {
+        if (signoutRedirect === undefined || signoutRedirect !== false) {
+            this.signingOut = true;
+            signoutRedirect = true;
+        }
+        return this.userManager.signoutRedirect();
+    }
+    getClientSettings(environment) {
+        return {
+            authority: environment?.openID?.authority,
+            client_id: environment?.openID?.client_id,
+            redirect_uri: environment?.openID?.redirect_uri,
+            post_logout_redirect_uri: environment?.openID?.post_logout_redirect_uri,
+            response_type: environment?.openID?.response_type,
+            scope: environment?.openID?.scope,
+            filterProtocolClaims: environment?.openID?.filterProtocolClaims,
+            loadUserInfo: true,
+            monitorSession: true,
+            silent_redirect_uri: environment?.openID?.silent_redirect_uri,
+            automaticSilentRenew: environment?.openID?.automaticSilentRenew,
+            accessTokenExpiringNotificationTime: 20,
+            checkSessionInterval: 2000,
+            silentRequestTimeout: 20000,
+        };
+    }
+    async isServiceReady() {
+        return new Promise(async (resolve, reject) => {
+            if (this.initialized) {
+                this.logger.info("[AuthService] isServiceReady", true);
+                resolve(true);
+            }
+            else {
+                this.logger.info("[AuthService] isServiceReady", false);
+                reject(false);
+            }
+        });
+    }
+}
+AuthService.USER_LOADED_EVENT = "USER_LOADED";
+AuthService.USER_UNLOADED_EVENT = "USER_UNLOADED";
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: AuthService, deps: [{ token: i1.LoggerService }, { token: i2.TokenHelperService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: AuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LoggerService }, { type: i2.TokenHelperService }]; } });
+export function authServiceFactory(authService, appSettings, environment) {
+    return async () => {
+        appSettings.isServiceReady.subscribe(item => {
+            if (item)
+                authService.initialize(environment);
+        });
+    };
+}
+;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../../../projects/falcon-ng/tailwind/src/lib/service/open-id/auth.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAgB,WAAW,EAAsB,MAAM,aAAa,CAAC;;;;AAS5E,MAAM,OAAO,WAAW;IAYtB,YAAoB,MAAqB,EAAU,kBAAsC;QAArE,WAAM,GAAN,MAAM,CAAe;QAAU,uBAAkB,GAAlB,kBAAkB,CAAoB;QARjF,gBAAW,GAAY,KAAK,CAAC;QAM7B,eAAU,GAAY,KAAK,CAAC;IAIpC,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,WAAiC;QAChD,IAAI,IAAI,CAAC,WAAW;YAAE,OAAO;QAC7B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAClD,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE;YAC3C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACnB,CAAC,CAAC,CAAC;QAGH,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,sBAAsB,CAAC,GAAG,EAAE;YAClD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,uBAAuB,GAAG,IAAI,IAAI,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,qBAAqB,CAAC,GAAG,EAAE;YACjD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sBAAsB,GAAG,IAAI,IAAI,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC;YACvE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE;YAC9C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,2BAA2B,GAAG,CAAC,CAAC,OAAO,GAAG,IAAI,IAAI,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC;YACzF,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE;YAC3C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,8BAA8B,GAAG,IAAI,IAAI,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC;YAC/E,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;YACzF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACnB,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE;YAC3C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,+BAA+B,GAAG,IAAI,IAAI,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC;YAEhF,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;gBACpB,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;aAC7E;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,EAAE;YAC5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,IAAI,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC;YACzE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;QAC7C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC1B,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;IACjD,CAAC;IAEM,OAAO;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;IACpC,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;IAC3B,CAAC;IAEM,SAAS;QACd,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;IAC3B,CAAC;IAEM,2BAA2B;QAChC,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI;YACnB,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;QAC7D,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;QACtG,CAAC;IACH,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,SAAiB;QACzC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mCAAmC,EAAE,SAAS,CAAC,CAAC;QACjE,MAAM,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC;QACzC,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,EAAC,IAAI,EAAE,EAAC,SAAS,EAAE,SAAS,EAAC,EAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;YAChF,+CAA+C;YAC/C,OAAO,GAAG,CAAC;QACb,CAAC,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,sBAAsB;QAC1B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;QACzD,IAAI,IAAI,GAAG,MAAM,IAAI,OAAO,CAAY,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC1D,IAAI,CAAC,WAAW,CAAC,sBAAsB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACpD,OAAO,CAAC,IAAI,CAAC,CAAA;YACf,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;gBACf,MAAM,CAAC,KAAK,CAAC,CAAC;YAChB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAEM,KAAK;QACV,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;IAC3C,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAEM,MAAM,CAAC,eAAyB;QAErC,IAAI,eAAe,KAAK,SAAS,IAAI,eAAe,KAAK,KAAK,EAAE;YAC9D,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,eAAe,GAAG,IAAI,CAAC;SACxB;QAED,OAAO,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC;IAC5C,CAAC;IAEO,iBAAiB,CAAC,WAAiC;QACzD,OAAO;YACL,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS;YACzC,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS;YACzC,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY;YAC/C,wBAAwB,EAAE,WAAW,EAAE,MAAM,EAAE,wBAAwB;YACvE,aAAa,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa;YACjD,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK;YACjC,oBAAoB,EAAE,WAAW,EAAE,MAAM,EAAE,oBAAoB;YAC/D,YAAY,EAAE,IAAI;YAClB,cAAc,EAAE,IAAI;YACpB,mBAAmB,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB;YAC7D,oBAAoB,EAAE,WAAW,EAAE,MAAM,EAAE,oBAAoB;YAC/D,mCAAmC,EAAE,EAAE;YACvC,oBAAoB,EAAE,IAAI;YAC1B,oBAAoB,EAAE,KAAK;SAC5B,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,cAAc;QAClB,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3C,IAAI,IAAI,CAAC,WAAW,EAAE;gBACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,8BAA8B,EAAE,IAAI,CAAC,CAAC;gBACvD,OAAO,CAAC,IAAI,CAAC,CAAC;aACf;iBAAM;gBACL,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,8BAA8B,EAAE,KAAK,CAAC,CAAC;gBACxD,MAAM,CAAC,KAAK,CAAC,CAAC;aACf;QACH,CAAC,CAAC,CAAC;IACL,CAAC;;AA7JM,6BAAiB,GAAG,aAAa,CAAC;AAClC,+BAAmB,GAAG,eAAe,CAAC;wGAFlC,WAAW;4GAAX,WAAW,cAFV,MAAM;2FAEP,WAAW;kBAHvB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;AAkKD,MAAM,UAAU,kBAAkB,CAAC,WAAwB,EAAE,WAA8B,EAAE,WAAiC;IAC5H,OAAO,KAAK,IAAI,EAAE;QAChB,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAC1C,IAAI,IAAI;gBACN,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;IACL,CAAC,CAAA;AACH,CAAC;AAAA,CAAC","sourcesContent":["import {Injectable} from '@angular/core';\nimport {Profile, User, UserManager, UserManagerSettings} from 'oidc-client';\nimport {LoggerService} from '../logger.service';\nimport {TokenHelperService} from './TokenHelperService';\nimport {EnvironmentViewModel} from \"../../model/environments\";\nimport {AppSettingService} from \"../appsetting.service\";\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AuthService {\n  static USER_LOADED_EVENT = \"USER_LOADED\";\n  static USER_UNLOADED_EVENT = \"USER_UNLOADED\";\n\n  private initialized: boolean = false;\n  private userManager!: UserManager;\n  private user: any;\n  public settings!: UserManagerSettings;\n\n  private accessToken!: Object;\n  private signingOut: boolean = false;\n\n  constructor(private logger: LoggerService, private tokenHelperService: TokenHelperService) {\n\n  }\n\n  async initialize(environment: EnvironmentViewModel): Promise<void> {\n    if (this.initialized) return;\n    this.settings = this.getClientSettings(environment);\n    this.userManager = new UserManager(this.settings);\n    this.userManager.events.addUserLoaded(user => {\n      this.user = user;\n    });\n\n\n    this.userManager.events.addAccessTokenExpiring(() => {\n      this.logger.info(\"IdSvr token expiring \" + new Date().toLocaleString());\n    });\n\n    this.userManager.events.addAccessTokenExpired(() => {\n      this.logger.info(\"IdSvr token expired \" + new Date().toLocaleString());\n      this.logout(false);\n    });\n\n    this.userManager.events.addSilentRenewError(e => {\n      this.logger.error(\"IdSvr silent renew error \" + e.message + new Date().toLocaleString());\n      this.logout(false);\n    });\n\n    this.userManager.events.addUserLoaded(user => {\n      this.logger.info(\"IdSvr user session is ready \" + new Date().toLocaleString());\n      this.accessToken = this.tokenHelperService.getPayloadFromToken(user.access_token, false);\n      this.user = user;\n    });\n\n    this.userManager.events.addUserUnloaded(() => {\n      this.logger.info(\"IdSvr user session has ended \" + new Date().toLocaleString());\n\n      if (!this.signingOut) {\n        this.startAuthentication(window.location.pathname + window.location.search);\n      }\n    });\n\n    this.userManager.events.addUserSignedOut(() => {\n      this.logger.info(\"IdSvr user signed out \" + new Date().toLocaleString());\n      this.logout(false);\n    });\n\n    this.user = await this.userManager.getUser();\n    this.initialized = true;\n  }\n\n  public isLoggedIn(): boolean {\n    return this.user != null && !this.user.expired;\n  }\n\n  public getUser(): Promise<User | null> {\n    return this.userManager.getUser();\n  }\n\n  public getProfile(): Profile {\n    return this.user.profile;\n  }\n\n  public getClaims(): Profile {\n    return this.user.profile;\n  }\n\n  public getAuthorizationHeaderValue(): string {\n    if (this.user != null)\n      return `${this.user.token_type} ${this.user.access_token}`;\n    return '';\n  }\n\n  getAccessToken(): any {\n    return this.accessToken || this.tokenHelperService.getPayloadFromToken(this.user.access_token, false);\n    ;\n  }\n\n  async startAuthentication(returnUrl: string): Promise<void> {\n    this.logger.info(\"[AuthService] startAuthentication\", returnUrl);\n    await this.userManager.clearStaleState();\n    await this.userManager.signinRedirect({data: {returnUrl: returnUrl}}).catch(err => {\n      //this.$log.debug(\"IdSvr sign in failed\", err);\n      return err;\n    });\n  }\n\n  async completeAuthentication(): Promise<Oidc.User> {\n    this.logger.info(\"[AuthService] completeAuthentication\");\n    let user = await new Promise<Oidc.User>((resolve, reject) => {\n      this.userManager.signinRedirectCallback().then(user => {\n        resolve(user)\n      }).catch(error => {\n        reject(error);\n      });\n    });\n    this.user = user;\n    return this.user;\n  }\n\n  public login(): Promise<void> {\n    return this.userManager.signinRedirect();\n  }\n\n  public renewToken(): Promise<User> {\n    return this.userManager.signinSilent();\n  }\n\n  public logout(signoutRedirect?: boolean): Promise<void> {\n\n    if (signoutRedirect === undefined || signoutRedirect !== false) {\n      this.signingOut = true;\n      signoutRedirect = true;\n    }\n\n    return this.userManager.signoutRedirect();\n  }\n\n  private getClientSettings(environment: EnvironmentViewModel): UserManagerSettings {\n    return {\n      authority: environment?.openID?.authority,\n      client_id: environment?.openID?.client_id,\n      redirect_uri: environment?.openID?.redirect_uri,\n      post_logout_redirect_uri: environment?.openID?.post_logout_redirect_uri,\n      response_type: environment?.openID?.response_type,\n      scope: environment?.openID?.scope,\n      filterProtocolClaims: environment?.openID?.filterProtocolClaims,\n      loadUserInfo: true,\n      monitorSession: true,\n      silent_redirect_uri: environment?.openID?.silent_redirect_uri,\n      automaticSilentRenew: environment?.openID?.automaticSilentRenew,\n      accessTokenExpiringNotificationTime: 20, //default 60\n      checkSessionInterval: 2000, //default 2000\n      silentRequestTimeout: 20000,\n    };\n  }\n\n  async isServiceReady(): Promise<boolean> {\n    return new Promise(async (resolve, reject) => {\n      if (this.initialized) {\n        this.logger.info(\"[AuthService] isServiceReady\", true);\n        resolve(true);\n      } else {\n        this.logger.info(\"[AuthService] isServiceReady\", false);\n        reject(false);\n      }\n    });\n  }\n}\n\nexport function authServiceFactory(authService: AuthService, appSettings: AppSettingService, environment: EnvironmentViewModel) {\n  return async () => {\n    appSettings.isServiceReady.subscribe(item => {\n      if (item)\n        authService.initialize(environment);\n    });\n  }\n};"]}

package/esm2020/public-api.mjs

@@ -0,0 +1,50 @@
+/*
+ * Public API Surface of falcon-core-module
+ */
+export * from './lib/module/angularmaterial.module';
+export * from './lib/falcon-core.module';
+export * from './lib/reactive-field.directive';
+/*
+ * Public API Surface of falcon core module service
+ */
+export * from './lib/service/http/igeneric-http-client';
+export * from './lib/service/logger.service';
+export * from './lib/service/open-id/auth.service';
+export * from './lib/service/open-id/auth-guard.service';
+export * from './lib/service/appsetting.service';
+/*
+ * Public control type
+ */
+export * from './lib/control-type/select';
+export * from './lib/control-type/textarea';
+export * from './lib/control-type/textbox';
+export * from './lib/model/enum';
+export * from './lib/model/constant';
+export * from './lib/model/environments';
+export * from './lib/model/ivalidator';
+export * from './lib/control-builder/control-builder.component';
+export * from './lib/base-form-component';
+/*
+ * Public component type
+ */
+export * from './lib/component/auto-complete/auto-complete.component';
+export * from './lib/component/snack-bar/snack-bar.component';
+export * from './lib/component/chips/chip.component';
+export * from './lib/component/table/table.component';
+export * from './lib/component/pagination/pagination.component';
+export * from './lib/component/rich-text-editor/rich-text-editor.component';
+export * from './lib/component/textbox/textbox.component';
+export * from './lib/component/textarea/textarea.component';
+export * from './lib/component/radio/radio.component';
+export * from './lib/component/select/select.component';
+export * from './lib/component/slide-toggle/slide-toggle.component';
+export * from './lib/component/slider/slider.component';
+export * from './lib/component/date-picker/date-picker.component';
+export * from './lib/component/dialog/dialog.component';
+export * from './lib/component/checkbox/checkbox.component';
+export * from './lib/component/progress-bar/progress-bar.component';
+export * from './lib/component/progress-spinner/progress-spinner.component';
+export * from './lib/component/bottom-sheet/bottom-sheet.component';
+export * from './lib/component/button-toggle/button-toggle.component';
+export * from './lib/component/button/button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2ZhbGNvbi1uZy90YWlsd2luZC9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGdDQUFnQyxDQUFDO0FBRy9DOztHQUVHO0FBQ0gsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLGtDQUFrQyxDQUFDO0FBR2pEOztHQUVHO0FBQ0gsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGlEQUFpRCxDQUFDO0FBQ2hFLGNBQWMsMkJBQTJCLENBQUM7QUFFMUM7O0dBRUc7QUFDSCxjQUFjLHVEQUF1RCxDQUFDO0FBQ3RFLGNBQWMsK0NBQStDLENBQUM7QUFDOUQsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsaURBQWlELENBQUM7QUFDaEUsY0FBYyw2REFBNkQsQ0FBQztBQUM1RSxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMsNkNBQTZDLENBQUM7QUFDNUQsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMscURBQXFELENBQUM7QUFDcEUsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLG1EQUFtRCxDQUFDO0FBQ2xFLGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLHFEQUFxRCxDQUFDO0FBQ3BFLGNBQWMsNkRBQTZELENBQUM7QUFDNUUsY0FBYyxxREFBcUQsQ0FBQztBQUNwRSxjQUFjLHVEQUF1RCxDQUFDO0FBQ3RFLGNBQWMseUNBQXlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGZhbGNvbi1jb3JlLW1vZHVsZVxuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2R1bGUvYW5ndWxhcm1hdGVyaWFsLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9mYWxjb24tY29yZS5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmVhY3RpdmUtZmllbGQuZGlyZWN0aXZlJztcblxuXG4vKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGZhbGNvbiBjb3JlIG1vZHVsZSBzZXJ2aWNlXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2UvaHR0cC9pZ2VuZXJpYy1odHRwLWNsaWVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlL2xvZ2dlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2Uvb3Blbi1pZC9hdXRoLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZS9vcGVuLWlkL2F1dGgtZ3VhcmQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlL2FwcHNldHRpbmcuc2VydmljZSc7XG5cblxuLypcbiAqIFB1YmxpYyBjb250cm9sIHR5cGVcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29udHJvbC10eXBlL3NlbGVjdCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb250cm9sLXR5cGUvdGV4dGFyZWEnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29udHJvbC10eXBlL3RleHRib3gnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWwvZW51bSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbC9jb25zdGFudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbC9lbnZpcm9ubWVudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWwvaXZhbGlkYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb250cm9sLWJ1aWxkZXIvY29udHJvbC1idWlsZGVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9iYXNlLWZvcm0tY29tcG9uZW50JztcblxuLypcbiAqIFB1YmxpYyBjb21wb25lbnQgdHlwZVxuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnQvYXV0by1jb21wbGV0ZS9hdXRvLWNvbXBsZXRlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnQvc25hY2stYmFyL3NuYWNrLWJhci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50L2NoaXBzL2NoaXAuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudC90YWJsZS90YWJsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50L3BhZ2luYXRpb24vcGFnaW5hdGlvbi5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50L3JpY2gtdGV4dC1lZGl0b3IvcmljaC10ZXh0LWVkaXRvci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50L3RleHRib3gvdGV4dGJveC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50L3RleHRhcmVhL3RleHRhcmVhLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnQvcmFkaW8vcmFkaW8uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudC9zZWxlY3Qvc2VsZWN0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnQvc2xpZGUtdG9nZ2xlL3NsaWRlLXRvZ2dsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50L3NsaWRlci9zbGlkZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudC9kYXRlLXBpY2tlci9kYXRlLXBpY2tlci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50L2RpYWxvZy9kaWFsb2cuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudC9jaGVja2JveC9jaGVja2JveC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50L3Byb2dyZXNzLWJhci9wcm9ncmVzcy1iYXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudC9wcm9ncmVzcy1zcGlubmVyL3Byb2dyZXNzLXNwaW5uZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudC9ib3R0b20tc2hlZXQvYm90dG9tLXNoZWV0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnQvYnV0dG9uLXRvZ2dsZS9idXR0b24tdG9nZ2xlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnQvYnV0dG9uL2J1dHRvbi5jb21wb25lbnQnO1xuIl19