@axa-fr/react-oidc 6.0.0-beta9 → 6.0.2

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;
-    }
-    
-    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
-        }
+    return { 
+        success : true,
+        data: parseOriginalTokens(tokens)
     };
 }
 
@@ -82,7 +70,6 @@ const internalFetch = async (url, headers, numberRetry=0) => {
                 throw e;
             }
         } else {
-            
             console.error(e.message);
             throw e; // rethrow other unexpected errors
         }
@@ -108,36 +95,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,42 +150,45 @@ 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);
+            const {tokens, status} = 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(status);
                 return;                
             }
-            oidc.publishEvent(Oidc.eventNames.token_renewed, {});
+            
             if(oidc.timeoutId) {
                 oidc.timeoutId = autoRenewTokens(oidc, tokens.refreshToken, oidc.tokens.expiresAt);
             }
-        } else{
-            const tokens = await oidc.syncTokensAsync();
-            if(tokens && oidc.timeoutId) {
-                oidc.timeoutId = autoRenewTokens(oidc, tokens.refreshToken, expiresAt);
-            }
-        }
+
     }, 1000);
 }
 
 const getLoginSessionKey = (configurationName:string, redirectUri:string) => {
     return `oidc_login.${configurationName}:${redirectUri}`;
 }
+
+const setLoginParams = (configurationName:string, redirectUri:string, data) =>{
+    const sessionKey = getLoginSessionKey(configurationName, redirectUri);
+    getLoginParamsCache = data
+    sessionStorage[sessionKey] = JSON.stringify(data);
+}
+
+let getLoginParamsCache = null;
 const getLoginParams = (configurationName, redirectUri) => {
-    return JSON.parse(sessionStorage[getLoginSessionKey(configurationName, redirectUri)]);
+    const dataString = sessionStorage[getLoginSessionKey(configurationName, redirectUri)];
+    if(!getLoginParamsCache){
+        getLoginParamsCache = JSON.parse(dataString);
+    }
+    return getLoginParamsCache;
 }
 
 const userInfoAsync = async (oidc) => {
@@ -238,11 +198,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,32 +228,11 @@ 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",
     logout_from_another_tab: "logout_from_another_tab",
+    logout_from_same_tab: "logout_from_same_tab",
     token_renewed: "token_renewed",
     token_timer: "token_timer",
     loginAsync_begin:"loginAsync_begin",
@@ -382,7 +325,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;
@@ -390,7 +338,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);
@@ -460,17 +408,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, {});
@@ -541,7 +478,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"});
@@ -575,8 +512,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;
@@ -600,16 +536,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);
@@ -636,7 +563,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
@@ -674,7 +601,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;
         }
@@ -691,28 +618,10 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     scope = configuration.scope;
                 }
 
-                const sessionKey = getLoginSessionKey(this.configurationName, redirectUri);
-                sessionStorage[sessionKey] = JSON.stringify({callbackPath: url, extras, state});
-
+                setLoginParams(this.configurationName, redirectUri, {callbackPath: url, extras, state});
+                
                 let serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName);
                 const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
-                /*if (serviceWorker && installServiceWorker) {
-                    const isServiceWorkerProxyActive = await serviceWorker.isServiceWorkerProxyActiveAsync();
-                    if (!isServiceWorkerProxyActive) {
-                        const isUnregistered = await serviceWorker.unregisterAsync();
-                        console.log("isUnregistered")
-                        console.log(isUnregistered)
-                        if(isUnregistered){
-                            serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName);
-                        }
-                        const extrasQueries = extras != null ? {...extras}: {};
-                        extrasQueries.callbackPath = url;
-                        extrasQueries.state = state;
-                        const queryString = buildQueries(extrasQueries);
-                        window.location.href = `${redirectUri}/service-worker-install${queryString}`;
-                        //return;
-                    }
-                }*/
                 let storage;
                 if (serviceWorker) {
                     serviceWorker.startKeepAliveServiceWorker();
@@ -781,9 +690,16 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         else {
                             console.debug("SessionMonitor._callback: Different subject signed into OP:", iFrameIdTokenPayload.sub);
                         }
-                    }).catch((e) => {
-                        this.publishEvent(eventNames.logout_from_another_tab, {});
-                        this.destroyAsync();
+                    }).catch(async (e) => {
+                        for (const [key, oidc] of Object.entries(oidcDatabase)) {
+                            //if(oidc !== this) {
+                                // @ts-ignore
+                               await oidc.logoutOtherTabAsync(this.configuration.client_id, idTokenPayload.sub);
+                            //}
+                        }
+                        //await this.destroyAsync();
+                        //this.publishEvent(eventNames.logout_from_another_tab, {message : "SessionMonitor"});
+                        
                     });
                 };
 
@@ -810,7 +726,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);
@@ -910,13 +826,19 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     }, tokenRequestTimeout ?? 12000);
                     try {
                         const tokenHandler = new BaseTokenRequestHandler(new FetchRequestor());
-                        tokenHandler.performTokenRequest(oidcServerConfiguration, tokenRequest).then((tokenResponse)=>{
-                            if(timeoutId) {
+                        tokenHandler.performTokenRequest(oidcServerConfiguration, tokenRequest).then(async (tokenResponse) => {
+                            if (timeoutId) {
                                 clearTimeout(timeoutId);
-                                this.timeoutId=null;
+                                this.timeoutId = null;
                                 const loginParams = getLoginParams(this.configurationName, redirectUri);
+
+                                if (serviceWorker) {
+                                    const {tokens} = await serviceWorker.initAsync(oidcServerConfiguration, "syncTokensAsync");
+                                    tokenResponse = tokens;
+                                }
+
                                 // @ts-ignore
-                                this.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, clientId, sessionState, isSilentSignin).then(() =>{
+                                this.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, clientId, sessionState, isSilentSignin).then(() => {
                                     this.publishEvent(eventNames.loginCallbackAsync_end, {});
                                     resolve({
                                         tokens: tokenResponse,
@@ -945,157 +867,154 @@ 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 silent_token_response = await this.silentLoginAsync();
+                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) {
-                    return silent_token_response.tokens;
+                    this.publishEvent(Oidc.eventNames.token_renewed, {});
+                    return {tokens:silent_token_response.tokens, status:"LOGGED"};
                 }
             } catch (exceptionSilent) {
                 console.error(exceptionSilent);
+                this.publishEvent(eventNames.refreshTokensAsync_silent_error, {message: "exceptionSilent" ,exception: exceptionSilent.message});
+                if(exceptionSilent && exceptionSilent.message && exceptionSilent.message.startsWith("oidc")){
+                    this.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token silent` });
+                    return {tokens:null, status:"SESSION_LOST"};
+                } 
+                await sleepAsync(1000);
+                throw exceptionSilent;
             }
-            if(this.timeoutId){
-                timer.clearTimeout(this.timeoutId);
-                this.timeoutId=null;
-            }
-            this.publishEvent(eventNames.refreshTokensAsync_error, {message: "refresh token and silent refresh failed"});
-            return null;
+            this.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token silent return` });
+            return {tokens:null, status:"SESSION_LOST"};
         }
-        
-            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);
+                    switch (status) {
+                        case "SESSION_LOST":
+                            this.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token session lost` });
+                            return {tokens:null, status:"SESSION_LOST"};
+                        case "NOT_CONNECTED":
+                            return {tokens:null, status:null};
+                        case "TOKENS_VALID":
+                        case "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID":
+                            return {tokens, status:"LOGGED_IN"};
+                        case "LOGOUT_FROM_ANOTHER_TAB":
+                            this.publishEvent(eventNames.logout_from_another_tab, {"status": "session syncTokensAsync"});
+                            return {tokens:null, status:"LOGGED_OUT"};
+                        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 {tokens: tokenResponse.data, status:"LOGGED_IN"};
+                            } 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++;
             }
-        
-     }
 
-    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;
-            }
+        this.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token` });
+        return {tokens:null, status:"SESSION_LOST"};
+     }
 
-            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, {});
-                    await this.destroyAsync();
-                    return null;
-                } else if (isLogin == null) {
-                    try {
-                        this.publishEvent(eventNames.syncTokensAsync_begin, {});
-                        const silent_token_response = await this.silentLoginAsync({prompt: "none"});
-                        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;
-                    }
+    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, configurationName);
+        if (serviceWorker) {
+            const {status, tokens} = await serviceWorker.initAsync(oidcServerConfiguration, "syncTokensAsync");
+            if (status == "LOGGED_OUT") {
+                return {tokens: null, status: "LOGOUT_FROM_ANOTHER_TAB"};
+            }else if (status == "SESSIONS_LOST") {
+                    return { tokens : null, status: "SESSIONS_LOST"};
+            } else if (!status || !tokens) {
+                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, status } = await session.initAsync();
+            if (!tokens) {
+                return {tokens: null, status: "LOGOUT_FROM_ANOTHER_TAB"};
+            } else if (status == "SESSIONS_LOST") {
+                    return { tokens : null, status: "SESSIONS_LOST"};
                 }
-            } 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, {});
-                    await this.destroyAsync();
-                    return null;
-                }
+            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){
@@ -1112,24 +1031,39 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
          return userInfoAsync(this);
      }
      
-     async destroyAsync() {
+     async destroyAsync(status) {
          timer.clearTimeout(this.timeoutId);
          this.timeoutId=null;
          if(this.checkSessionIFrame){
              this.checkSessionIFrame.stop();
          }
         if(this.serviceWorker){
-            await this.serviceWorker.clearAsync();
+            await this.serviceWorker.clearAsync(status);
         }
          if(this.session){
-             await this.session.clearAsync();
+             await this.session.clearAsync(status);
          }
          this.tokens = null;
          this.userInfo = null;
-         this.events = [];
-         
+        // this.events = [];
      }
      
+     async logoutSameTabAsync(clientId, sub){
+         // @ts-ignore
+         if(this.configuration.monitor_session&& this.configuration.client_id === clientId && sub && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === sub) {
+             this.publishEvent(eventNames.logout_from_same_tab, {"message": sub});
+             await this.destroyAsync("LOGGED_OUT");
+         }
+     }
+
+    async logoutOtherTabAsync(clientId, sub){
+        // @ts-ignore
+        if(this.configuration.monitor_session && this.configuration.client_id === clientId && sub && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === sub) {
+            await this.destroyAsync("LOGGED_OUT");
+            this.publishEvent(eventNames.logout_from_another_tab, {message : "SessionMonitor", "sub": sub});
+        }
+    }
+     
     async logoutAsync(callbackPathOrUrl: string | undefined = undefined, extras: StringMap = null) {
         const configuration = this.configuration;
         const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
@@ -1146,7 +1080,16 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
 		const url = isUri ? callbackPathOrUrl : window.location.origin + path;
         // @ts-ignore
         const idToken = this.tokens ? this.tokens.idToken : "";
-        await this.destroyAsync();  
+        // @ts-ignore
+        const sub = this.tokens && this.tokens.idTokenPayload ? this.tokens.idTokenPayload.sub : null;
+        await this.destroyAsync("LOGGED_OUT");
+        for (const [key, oidc] of Object.entries(oidcDatabase)) {
+            if(oidc !== this) {
+                // @ts-ignore
+                await oidc.logoutSameTabAsync(this.configuration.client_id, sub);
+            }
+        }
+        
         if(oidcServerConfiguration.endSessionEndpoint) {
             let extraQueryString = "";
             if(extras){