@axa-fr/react-oidc 6.0.0-beta12 → 6.0.0-beta15

package/src/oidc/vanilla/oidc.ts

@@ -19,6 +19,7 @@ import timer from './timer';
 import {CheckSessionIFrame} from "./checkSessionIFrame"
 import {getParseQueryStringFromLocation} from "./route-utils";
 import {AuthorizationServiceConfigurationJson} from "@openid/appauth/src/authorization_service_configuration";
+import {computeTimeLeft, isTokensValid, parseOriginalTokens, setTokens} from "./parseTokens";
 
 const performTokenRequestAsync= async (url, details, extras) => {
     
@@ -47,22 +48,9 @@ const performTokenRequestAsync= async (url, details, extras) => {
         return {success:false, status: response.status}
     }
     const tokens = await response.json();
-
-    if(!tokens.issued_at) {
-        const currentTimeUnixSecond = new Date().getTime() /1000;
-        tokens.issued_at = currentTimeUnixSecond;
-    }
-    
+    console.log(tokens);
     return { success : true,
-        data : {
-            accessToken: tokens.access_token,
-            expiresIn: tokens.expires_in,
-            idToken: tokens.id_token,
-            refreshToken: tokens.refresh_token,
-            scope: tokens.scope,
-            tokenType: tokens.token_type,
-            issuedAt: tokens.issued_at
-        }
+        data: parseOriginalTokens(tokens)
     };
 }
 
@@ -108,36 +96,6 @@ export class OidcAuthorizationServiceConfiguration extends AuthorizationServiceC
     
 }
 
-const idTokenPayload = (token) => {
-    const base64Url = token.split('.')[1];
-    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
-    const jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
-        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
-    }).join(''));
-
-    return JSON.parse(jsonPayload);
-}
-
-const countLetter = (str, find)=> {
-    return (str.split(find)).length - 1;
-}
-
-const extractAccessTokenPayload = tokens => {
-    if(tokens.accessTokenPayload)
-    {
-        return tokens.accessTokenPayload;
-    }
-    const accessToken = tokens.accessToken;
-    try{
-        if (!accessToken || countLetter(accessToken,'.') != 2) {
-            return null;
-        }
-        return JSON.parse(atob(accessToken.split('.')[1]));
-    } catch (e) {
-        console.warn(e);
-    }
-    return null;
-};
 
 export interface StringMap {
     [key: string]: string;
@@ -193,34 +151,41 @@ const loginCallbackWithAutoTokensRenewAsync = async (oidc) => {
 }
 
 const autoRenewTokens = (oidc, refreshToken, expiresAt) => {
-    const refreshTimeBeforeTokensExpirationInSecond = oidc.configuration.refresh_time_before_tokens_expiration_in_second ?? 60;
+    const refreshTimeBeforeTokensExpirationInSecond = oidc.configuration.refresh_time_before_tokens_expiration_in_second;
     return timer.setTimeout(async () => {
-        const currentTimeUnixSecond = new Date().getTime() /1000;
-        const timeInfo = { timeLeft: Math.round(((expiresAt - refreshTimeBeforeTokensExpirationInSecond) - currentTimeUnixSecond))};
+        const timeLeft = computeTimeLeft(refreshTimeBeforeTokensExpirationInSecond, expiresAt);
+        const timeInfo = { timeLeft };
         oidc.publishEvent(Oidc.eventNames.token_timer, timeInfo);
-        if(currentTimeUnixSecond > (expiresAt - refreshTimeBeforeTokensExpirationInSecond)) {
-            const tokens = await oidc.refreshTokensAsync(refreshToken);
-            oidc.tokens= await setTokensAsync(oidc.serviceWorker, tokens);
+       // if(timeLeft <= 0) {
+            const tokens = await oidc.synchroniseTokensAsync(refreshToken);
+            oidc.tokens= tokens;
             if(!oidc.serviceWorker){
                 await oidc.session.setTokens(oidc.tokens);
             }
             if(!oidc.tokens){
-                if(oidc.checkSessionIFrame){
-                    oidc.checkSessionIFrame.stop();
-                    oidc.checkSessionIFrame = null;
-                }
+                await oidc.destroyAsync();
+                oidc.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token` });
                 return;                
             }
-            oidc.publishEvent(Oidc.eventNames.token_renewed, {});
+            
             if(oidc.timeoutId) {
                 oidc.timeoutId = autoRenewTokens(oidc, tokens.refreshToken, oidc.tokens.expiresAt);
             }
-        } else{
+        /*} else{
             const tokens = await oidc.syncTokensAsync();
+            oidc.tokens = tokens;
+            if(!oidc.serviceWorker){
+                await oidc.session.setTokens(oidc.tokens);
+            }
+            if(!oidc.tokens){
+                oidc.publishEvent(eventNames.refreshTokensAsync_error, {message: `sync` });
+                await oidc.destroyAsync();
+                return;
+            }
             if(tokens && oidc.timeoutId) {
                 oidc.timeoutId = autoRenewTokens(oidc, tokens.refreshToken, tokens.expiresAt);
             }
-        }
+        }*/
     }, 1000);
 }
 
@@ -238,11 +203,15 @@ const userInfoAsync = async (oidc) => {
     if(!oidc.tokens){
         return null;
     }
-    if(oidc.syncTokensAsyncPromise){
-        await oidc.syncTokensAsyncPromise;
-    }
     const accessToken = oidc.tokens.accessToken;
-
+    if(!accessToken){
+        return null;
+    }
+    // We wait the synchronisation before making a request
+    while (oidc.tokens && !isTokensValid(oidc.tokens)){
+        await sleepAsync(200);
+    }
+    
     const oidcServerConfiguration = await oidc.initAsync(oidc.configuration.authority, oidc.configuration.authority_configuration);
    const url = oidcServerConfiguration.userInfoEndpoint;
    const fetchUserInfo = async (accessToken) => {
@@ -264,28 +233,6 @@ const userInfoAsync = async (oidc) => {
    return userInfo;
 }
 
-const setTokensAsync = async (serviceWorker, tokens) =>{
-    let accessTokenPayload;
-    if(tokens == null){
-        if(serviceWorker){
-            await serviceWorker.clearAsync();
-        }
-        return null;
-    }
-    if(serviceWorker){
-        accessTokenPayload = await serviceWorker.getAccessTokenPayloadAsync();
-    }
-    else {
-        accessTokenPayload = extractAccessTokenPayload(tokens);
-    }
-    const _idTokenPayload = idTokenPayload(tokens.idToken);
-
-    const idTokenExipreAt =(_idTokenPayload && _idTokenPayload.exp) ? _idTokenPayload.exp: Number.MAX_VALUE;
-    const accessTokenExpiresAt =  (accessTokenPayload && accessTokenPayload.exp)? accessTokenPayload.exp : tokens.issuedAt + tokens.expiresIn;
-    const expiresAt = idTokenExipreAt < accessTokenExpiresAt ? idTokenExipreAt : accessTokenExpiresAt;
-    return {...tokens, idTokenPayload: _idTokenPayload, accessTokenPayload, expiresAt};
-}
-
 const eventNames = {
     service_worker_not_supported_by_browser: "service_worker_not_supported_by_browser",
     token_aquired: "token_aquired",
@@ -383,7 +330,12 @@ export class Oidc {
             silent_login_uri = `${configuration.silent_redirect_uri.replace("-callback", "").replace("callback", "")}-login`; 
         }
         
-        this.configuration = {...configuration, silent_login_uri};
+        this.configuration = {...configuration, 
+            silent_login_uri, 
+            monitor_session: configuration.monitor_session ?? true,
+            refresh_time_before_tokens_expiration_in_second : configuration.refresh_time_before_tokens_expiration_in_second ?? 60,
+            silent_login_timeout: configuration.silent_login_timeout ?? 12000,
+        };
         this.configurationName= configurationName;
       this.tokens = null
       this.userInfo = null;
@@ -391,7 +343,7 @@ export class Oidc {
       this.timeoutId = null;
       this.serviceWorker = null;
       this.session = null;
-      this.refreshTokensAsync.bind(this);
+      this.synchroniseTokensAsync.bind(this);
       this.loginCallbackWithAutoTokensRenewAsync.bind(this);
       this.initAsync.bind(this);
       this.loginCallbackAsync.bind(this);
@@ -461,17 +413,6 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         if (!this.configuration.silent_redirect_uri || !this.configuration.silent_login_uri) {
             return Promise.resolve(null);
         }
-        while (document.hidden) {
-            await sleepAsync(1000);
-            this.publishEvent(eventNames.silentLoginAsync, {message:"wait because document is hidden"});
-        }
-
-        let numberTryOnline = 6;
-        while (!navigator.onLine && numberTryOnline > 0) {
-            await sleepAsync(1000);
-            numberTryOnline--;
-            this.publishEvent(eventNames.refreshTokensAsync, {message: `wait because navigator is offline try ${numberTryOnline}` });
-        }
             
         try {
             this.publishEvent(eventNames.silentLoginAsync_begin, {});
@@ -542,7 +483,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                             }
                         }
                     };
-                    const silentSigninTimeout = configuration.silent_login_timeout ?? 12000
+                    const silentSigninTimeout = configuration.silent_login_timeout;
                     setTimeout(() => {
                         if (!isResolved) {
                             self.publishEvent(eventNames.silentLoginAsync_error, {reason: "timeout"});
@@ -576,8 +517,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
 
         const serviceWorker = await initWorkerAsync(this.configuration.service_worker_relative_url, this.configurationName);
         const storage = serviceWorker ? window.localStorage : null;
-        const initAsyncPromise = await fetchFromIssuer(authority, this.configuration.authority_time_cache_wellknowurl_in_second ?? 60 * 60, storage);
-        return initAsyncPromise;
+        return await fetchFromIssuer(authority, this.configuration.authority_time_cache_wellknowurl_in_second ?? 60 * 60, storage);
     }
 
     tryKeepExistingSessionPromise = null;
@@ -601,16 +541,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     if (tokens) {
                         serviceWorker.startKeepAliveServiceWorker();
                         // @ts-ignore
-                        const reformattedToken = {
-                            accessToken : tokens.access_token,
-                            refreshToken : tokens.refresh_token,
-                            expiresIn: tokens.expires_in,
-                            idToken: tokens.id_token,
-                            scope: tokens.scope,
-                            tokenType: tokens.token_type,
-                            issuedAt: tokens.issued_at
-                        }
-                        this.tokens = await setTokensAsync(serviceWorker, reformattedToken);
+                        this.tokens = tokens;
                         this.serviceWorker = serviceWorker;
                         // @ts-ignore
                         this.timeoutId = autoRenewTokens(this, this.tokens.refreshToken, this.tokens.expiresAt);
@@ -637,7 +568,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     const {tokens} = await session.initAsync();
                     if (tokens) {
                         // @ts-ignore
-                        this.tokens = await setTokensAsync(serviceWorker, tokens);
+                        this.tokens = setTokens(tokens);
                         //session.setTokens(this.tokens);
                         this.session = session;
                         // @ts-ignore
@@ -675,7 +606,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
     }
 
     loginPromise: Promise<any>=null;
-    async loginAsync(callbackPath:string=undefined, extras:StringMap=null, installServiceWorker=true, state:string=undefined, isSilentSignin:boolean=false, scope:string=undefined) {
+    async loginAsync(callbackPath:string=undefined, extras:StringMap=null, state:string=undefined, isSilentSignin:boolean=false, scope:string=undefined) {
         if(this.loginPromise !== null){
             return this.loginPromise;
         }
@@ -801,7 +732,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             const response = await this._loginCallbackAsync(isSilenSignin);
             // @ts-ignore
             const tokens = response.tokens;
-            const parsedTokens = await setTokensAsync(this.serviceWorker, tokens);
+            const parsedTokens = setTokens(tokens);
             this.tokens = parsedTokens;
             if(!this.serviceWorker){
                 await this.session.setTokens(parsedTokens);
@@ -936,158 +867,140 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         }
     }
 
-    async refreshTokensAsync(refreshToken) {
+    async synchroniseTokensAsync(refreshToken, index=0) {
         
+            if (document.hidden) {
+                await sleepAsync(1000);
+                this.publishEvent(eventNames.refreshTokensAsync, {message: "wait because document is hidden"});
+                return await this.synchroniseTokensAsync(refreshToken, index);
+            }
+            let numberTryOnline = 6;
+            while (!navigator.onLine && numberTryOnline > 0) {
+                await sleepAsync(1000);
+                numberTryOnline--;
+                this.publishEvent(eventNames.refreshTokensAsync, {message: `wait because navigator is offline try ${numberTryOnline}` });
+            }
+
+        const configuration = this.configuration;
         const localsilentLoginAsync= async () => {
             try {
                 const loginParams = getLoginParams(this.configurationName, configuration.redirect_uri);
-                const silent_token_response = await this.silentLoginAsync(loginParams.extras, loginParams.state);
+                const silent_token_response = await this.silentLoginAsync({
+                    ...loginParams.extras,
+                    prompt: "none"
+                }, loginParams.state);
                 if (silent_token_response) {
+                    this.publishEvent(Oidc.eventNames.token_renewed, {});
                     return silent_token_response.tokens;
                 }
             } catch (exceptionSilent) {
-                console.error(exceptionSilent);
-            }
-            if(this.timeoutId){
-                timer.clearTimeout(this.timeoutId);
-                this.timeoutId=null;
+                if(exceptionSilent && exceptionSilent.message && exceptionSilent.message.startsWith("oidc")){
+                    return null;
+                }
+                throw exceptionSilent;
             }
-            this.publishEvent(eventNames.refreshTokensAsync_error, {message: "refresh token and silent refresh failed"});
             return null;
         }
-        
-            const configuration = this.configuration;
-            const clientId = configuration.client_id;
-            const redirectUri = configuration.redirect_uri;
-            const authority =  configuration.authority;
-            
-            if(!refreshToken)
-            {
-                return await localsilentLoginAsync();
-            }
             
-            let extras = {};
-            if(configuration.token_request_extras) {
-                for (let [key, value] of Object.entries(configuration.token_request_extras)) {
-                    extras[key] = value;
-                }
-            }
-            const oidcServerConfiguration = await this.initAsync(authority, configuration.authority_configuration);
-
-            const details = {
-                client_id: clientId,
-                redirect_uri: redirectUri,
-                grant_type: GRANT_TYPE_REFRESH_TOKEN,
-                refresh_token: refreshToken,
-            };
-            
-            let index = 0;
-            while (index <=4) {
+            if (index <=4) {
                 try {
-                    this.publishEvent(eventNames.refreshTokensAsync_begin, {refreshToken:refreshToken, tryNumber: index});
-                    if(index > 1) {
-                        while (document.hidden) {
-                            await sleepAsync(1000);
-                            this.publishEvent(eventNames.refreshTokensAsync, {message: "wait because document is hidden"});
-                        }
-                        let numberTryOnline = 6;
-                        while (!navigator.onLine && numberTryOnline > 0) {
-                            await sleepAsync(1000);
-                            numberTryOnline--;
-                            this.publishEvent(eventNames.refreshTokensAsync, {message: `wait because navigator is offline try ${numberTryOnline}` });
-                        }
-                    }
-                    const tokenResponse = await performTokenRequestAsync(oidcServerConfiguration.tokenEndpoint, details, extras)
-                    if (tokenResponse.success) {
-                        this.publishEvent(eventNames.refreshTokensAsync_end, {success: tokenResponse.success});
-                        return tokenResponse.data;
-                    } else {
-                        this.publishEvent(eventNames.refreshTokensAsync_silent_error, {message: "bad request" , tokenResponse: tokenResponse});
+                    
+                    if(!refreshToken)
+                    {
+                        this.publishEvent(eventNames.refreshTokensAsync_begin, {refreshToken:refreshToken, tryNumber: index});
                         return await localsilentLoginAsync();
                     }
+                    const { status, tokens } = await this.syncTokensInfoAsync(configuration, this.configurationName, this.tokens);
+                   // this.publishEvent(eventNames.refreshTokensAsync, {message: `status ${status}` });
+                    switch (status) {
+                        case "NOT_CONNECTED":
+                            return null;
+                        case "TOKENS_VALID":
+                        case "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID":
+                            return tokens;
+                        case "LOGOUT_FROM_ANOTHER_TAB":
+                            this.publishEvent(eventNames.logout_from_another_tab, {"status": "session syncTokensAsync"});
+                            return null;
+                        case "REQUIRE_SYNC_TOKENS":
+                            this.publishEvent(eventNames.refreshTokensAsync_begin, {refreshToken:refreshToken, status, tryNumber: index});
+                            return await localsilentLoginAsync();
+                        default:
+                            this.publishEvent(eventNames.refreshTokensAsync_begin, {refreshToken:refreshToken, status, tryNumber: index});
+                            const clientId = configuration.client_id;
+                            const redirectUri = configuration.redirect_uri;
+                            const authority =  configuration.authority;
+                            let extras = {};
+                            if(configuration.token_request_extras) {
+                                for (let [key, value] of Object.entries(configuration.token_request_extras)) {
+                                    extras[key] = value;
+                                }
+                            }
+                            const details = {
+                                client_id: clientId,
+                                redirect_uri: redirectUri,
+                                grant_type: GRANT_TYPE_REFRESH_TOKEN,
+                                refresh_token: tokens.refreshToken,
+                            };
+                            const oidcServerConfiguration = await this.initAsync(authority, configuration.authority_configuration);
+                            const tokenResponse = await performTokenRequestAsync(oidcServerConfiguration.tokenEndpoint, details, extras)
+                            if (tokenResponse.success) {
+                                this.publishEvent(eventNames.refreshTokensAsync_end, {success: tokenResponse.success});
+                                this.publishEvent(Oidc.eventNames.token_renewed, {});
+                                return tokenResponse.data;
+                            } else {
+                                this.publishEvent(eventNames.refreshTokensAsync_silent_error, {
+                                    message: "bad request",
+                                    tokenResponse: tokenResponse
+                                });
+                                return await this.synchroniseTokensAsync(null, index+1);
+                            }
+                    }
                 } catch (exception) {
                     console.error(exception);
                     this.publishEvent(eventNames.refreshTokensAsync_silent_error, {message: "exception" ,exception: exception.message});
+                    return this.synchroniseTokensAsync(refreshToken, index+1);
                 }
-                index++;
             }
-        
+        return null;
      }
 
-    syncTokensAsyncPromise=null;
-    async syncTokensAsync() {
-        
-        const localSyncTokensAsync = async () => {
-            // Service Worker can be killed by the browser (when it wants,for example after 10 seconds of inactivity, so we retreieve the session if it happen)
-            const configuration = this.configuration;
-            if (!this.tokens) {
-                return null;
-            }
+    async syncTokensInfoAsync(configuration, configurationName, currentTokens)  {
+        // Service Worker can be killed by the browser (when it wants,for example after 10 seconds of inactivity, so we retreieve the session if it happen)
+        //const configuration = this.configuration;
+        if (!currentTokens) {
+            return { tokens : null, status: "NOT_CONNECTED"};
+        }
 
-            const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
-            const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName);
-            if (serviceWorker) {
-                const {isLogin} = await serviceWorker.initAsync(oidcServerConfiguration, "syncTokensAsync");
-                if (isLogin == false) {
-                    this.publishEvent(eventNames.logout_from_another_tab, {"message": "service worker syncTokensAsync"});
-                    await this.destroyAsync();
-                    return null;
-                } else if (isLogin == null) {
-                    try {
-                        this.publishEvent(eventNames.syncTokensAsync_begin, {});
-                        const loginParams = getLoginParams(this.configurationName, configuration.redirect_uri);
-                        const silent_token_response = await this.silentLoginAsync({...loginParams.extras,prompt: "none"}, loginParams.state);
-                        if (silent_token_response && silent_token_response.tokens) {
-                            this.tokens = await setTokensAsync(serviceWorker, silent_token_response.tokens);
-                            this.publishEvent(eventNames.syncTokensAsync_end, {});
-                            return this.tokens;
-                        } else {
-                            this.publishEvent(eventNames.syncTokensAsync_error, {message: "no token found in result"});
-                            if (this.timeoutId) {
-                                timer.clearTimeout(this.timeoutId);
-                                this.timeoutId = null;
-                            }
-                            this.publishEvent(eventNames.syncTokensAsync_end, {});
-                            return null;
-                        }
-                    } catch (exceptionSilent) {
-                        console.error(exceptionSilent);
-                        this.publishEvent(eventNames.syncTokensAsync_error, exceptionSilent);
-                        if (this.timeoutId) {
-                            timer.clearTimeout(this.timeoutId);
-                            this.timeoutId = null;
-                        }
-                        this.publishEvent(eventNames.syncTokensAsync_end, {});
-                        return null;
-                    }
-                }
-            } else {
-                const session = initSession(this.configurationName, configuration.redirect_uri, configuration.storage ?? sessionStorage);
-                const {tokens} = await session.initAsync();
-                if (!tokens) {
-                    this.publishEvent(eventNames.logout_from_another_tab, {"message": "session syncTokensAsync"});
-                    await this.destroyAsync();
-                    return null;
-                }
+        const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
+        const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, configurationName);
+        if (serviceWorker) {
+            const {isLogin, tokens} = await serviceWorker.initAsync(oidcServerConfiguration, "syncTokensAsync");
+            if (isLogin == false) {
+                return { tokens : null, status: "LOGOUT_FROM_ANOTHER_TAB"};
+            } else if (isLogin == null) {
+                return { tokens : null, status: "REQUIRE_SYNC_TOKENS"};
+            } else if(tokens.issuedAt !== currentTokens.issuedAt) {
+                const timeLeft = computeTimeLeft(configuration.refresh_time_before_tokens_expiration_in_second, tokens.expiresAt);
+                const status = (timeLeft > 0) ? "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID" : "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_INVALID";
+                return { tokens : tokens, status };
+            }
+        } else {
+            const session = initSession(configurationName, configuration.redirect_uri, configuration.storage ?? sessionStorage);
+            const {tokens} = await session.initAsync();
+            if (!tokens) {
+                return { tokens : null, status: "LOGOUT_FROM_ANOTHER_TAB"};
+            } else if(tokens.issuedAt !== currentTokens.issuedAt){
+                const timeLeft = computeTimeLeft(configuration.refresh_time_before_tokens_expiration_in_second, tokens.expiresAt);
+                const status = (timeLeft > 0) ? "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID" : "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_INVALID";
+                return { tokens : tokens, status };
             }
-            return this.tokens;
-        }
-        
-        if(this.syncTokensAsyncPromise){
-            return this.syncTokensAsyncPromise;
         }
 
-        this.syncTokensAsyncPromise = localSyncTokensAsync().then(result =>{
-            if(this.syncTokensAsyncPromise){
-                this.syncTokensAsyncPromise = null;
-            }
-            return result;
-        });
-        
-        return this.syncTokensAsyncPromise
+        const timeLeft = computeTimeLeft(configuration.refresh_time_before_tokens_expiration_in_second, currentTokens.expiresAt);
+        const status = (timeLeft > 0) ? "TOKENS_VALID" : "TOKENS_INVALID";
+        return { tokens:currentTokens, status};
     }
 
-
     loginCallbackWithAutoTokensRenewPromise:Promise<loginCallbackResult> = null;
      loginCallbackWithAutoTokensRenewAsync():Promise<loginCallbackResult>{
          if(this.loginCallbackWithAutoTokensRenewPromise !== null){
@@ -1131,7 +1044,6 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
 
     async logoutOtherTabAsync(sub){
         // @ts-ignore
-        
         if(this.configuration.monitor_session && sub && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === sub) {
             await this.destroyAsync();
             console.log("logoutOtherTabAsync(sub)" +this.configurationName);

package/src/oidc/vanilla/parseTokens.js

@@ -0,0 +1,104 @@
+const idTokenPayload = (token) => {
+    const base64Url = token.split('.')[1];
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
+        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+    }).join(''));
+
+    return JSON.parse(jsonPayload);
+}
+
+const countLetter = (str, find)=> {
+    return (str.split(find)).length - 1;
+}
+
+const extractAccessTokenPayload = tokens => {
+    if(tokens.accessTokenPayload)
+    {
+        return tokens.accessTokenPayload;
+    }
+    const accessToken = tokens.accessToken;
+    try{
+        if (!accessToken || countLetter(accessToken,'.') !== 2) {
+            return null;
+        }
+        return JSON.parse(atob(accessToken.split('.')[1]));
+    } catch (e) {
+        console.warn(e);
+    }
+    return null;
+};
+
+
+export const setTokens = (tokens) =>{
+    
+    if(!tokens){
+        return null;
+    }
+    let accessTokenPayload;
+
+    if(!tokens.issuedAt) {
+        const currentTimeUnixSecond = new Date().getTime() /1000;
+        tokens.issuedAt = currentTimeUnixSecond;
+    }
+
+    if(tokens.accessTokenPayload !== undefined) {
+        accessTokenPayload = tokens.accessTokenPayload;
+    }
+    else {
+        accessTokenPayload = extractAccessTokenPayload(tokens);
+    }
+    const _idTokenPayload = idTokenPayload(tokens.idToken);
+
+    const idTokenExipreAt =(_idTokenPayload && _idTokenPayload.exp) ? _idTokenPayload.exp: Number.MAX_VALUE;
+    const accessTokenExpiresAt =  (accessTokenPayload && accessTokenPayload.exp)? accessTokenPayload.exp : tokens.issuedAt + tokens.expiresIn;
+    const expiresAt = idTokenExipreAt < accessTokenExpiresAt ? idTokenExipreAt : accessTokenExpiresAt;
+    
+    return {...tokens, idTokenPayload: _idTokenPayload, accessTokenPayload, expiresAt};
+}
+
+
+export const parseOriginalTokens= (tokens) =>{
+    if(!tokens){
+        return null;
+    }
+    if(!tokens.issued_at) {
+        const currentTimeUnixSecond = new Date().getTime() /1000;
+        tokens.issued_at = currentTimeUnixSecond;
+    }
+    
+    const data = {
+        accessToken: tokens.access_token,
+        expiresIn: tokens.expires_in,
+        idToken: tokens.id_token,
+        refreshToken: tokens.refresh_token,
+        scope: tokens.scope,
+        tokenType: tokens.token_type,
+        issuedAt: tokens.issued_at
+    };
+
+
+    if(tokens.accessTokenPayload !== undefined){
+        // @ts-ignore
+        data.accessTokenPayload = tokens.accessTokenPayload;
+    }
+
+    if(tokens.idTokenPayload !== undefined){
+        // @ts-ignore
+        data.idTokenPayload = tokens.idTokenPayload;
+    }
+
+    return setTokens(data);
+}
+
+export const computeTimeLeft = (refreshTimeBeforeTokensExpirationInSecond, expiresAt)=>{
+    const currentTimeUnixSecond = new Date().getTime() /1000;
+    return Math.round(((expiresAt - refreshTimeBeforeTokensExpirationInSecond) - currentTimeUnixSecond));
+}
+
+export const isTokensValid= (tokens) =>{
+    if(!tokens){
+        return false;
+    }
+    return computeTimeLeft(0, tokens.expiresAt) > 0;
+}