@axa-fr/oidc-client 6.26.6

package/src/initWorker.ts

@@ -0,0 +1,321 @@
+import { parseOriginalTokens } from './parseTokens.js';
+import timer from './timer.js';
+import { OidcConfiguration } from './types.js';
+
+export const getOperatingSystem = (navigator) => {
+    const nVer = navigator.appVersion;
+    const nAgt = navigator.userAgent;
+    const unknown = '-';
+    // system
+    let os = unknown;
+    const clientStrings = [
+        { s: 'Windows 10', r: /(Windows 10.0|Windows NT 10.0)/ },
+        { s: 'Windows 8.1', r: /(Windows 8.1|Windows NT 6.3)/ },
+        { s: 'Windows 8', r: /(Windows 8|Windows NT 6.2)/ },
+        { s: 'Windows 7', r: /(Windows 7|Windows NT 6.1)/ },
+        { s: 'Windows Vista', r: /Windows NT 6.0/ },
+        { s: 'Windows Server 2003', r: /Windows NT 5.2/ },
+        { s: 'Windows XP', r: /(Windows NT 5.1|Windows XP)/ },
+        { s: 'Windows 2000', r: /(Windows NT 5.0|Windows 2000)/ },
+        { s: 'Windows ME', r: /(Win 9x 4.90|Windows ME)/ },
+        { s: 'Windows 98', r: /(Windows 98|Win98)/ },
+        { s: 'Windows 95', r: /(Windows 95|Win95|Windows_95)/ },
+        { s: 'Windows NT 4.0', r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/ },
+        { s: 'Windows CE', r: /Windows CE/ },
+        { s: 'Windows 3.11', r: /Win16/ },
+        { s: 'Android', r: /Android/ },
+        { s: 'Open BSD', r: /OpenBSD/ },
+        { s: 'Sun OS', r: /SunOS/ },
+        { s: 'Chrome OS', r: /CrOS/ },
+        { s: 'Linux', r: /(Linux|X11(?!.*CrOS))/ },
+        { s: 'iOS', r: /(iPhone|iPad|iPod)/ },
+        { s: 'Mac OS X', r: /Mac OS X/ },
+        { s: 'Mac OS', r: /(Mac OS|MacPPC|MacIntel|Mac_PowerPC|Macintosh)/ },
+        { s: 'QNX', r: /QNX/ },
+        { s: 'UNIX', r: /UNIX/ },
+        { s: 'BeOS', r: /BeOS/ },
+        { s: 'OS/2', r: /OS\/2/ },
+        { s: 'Search Bot', r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\/Teoma|ia_archiver)/ },
+    ];
+    for (const id in clientStrings) {
+        const cs = clientStrings[id];
+        if (cs.r.test(nAgt)) {
+            os = cs.s;
+            break;
+        }
+    }
+
+    let osVersion = unknown;
+
+    if (/Windows/.test(os)) {
+        osVersion = /Windows (.*)/.exec(os)[1];
+        os = 'Windows';
+    }
+
+    switch (os) {
+        case 'Mac OS':
+        case 'Mac OS X':
+        case 'Android':
+            osVersion = /(?:Android|Mac OS|Mac OS X|MacPPC|MacIntel|Mac_PowerPC|Macintosh) ([._\d]+)/.exec(nAgt)[1];
+            break;
+
+        case 'iOS': {
+            const osVersionArray = /OS (\d+)_(\d+)_?(\d+)?/.exec(nVer);
+            osVersion = osVersionArray[1] + '.' + osVersionArray[2] + '.' + (parseInt(osVersionArray[3]) | 0);
+            break;
+        }
+    }
+    return {
+        os,
+        osVersion,
+    };
+};
+
+function getBrowser() {
+    const ua = navigator.userAgent; let tem;
+        let M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+    if (/trident/i.test(M[1])) {
+        tem = /\brv[ :]+(\d+)/g.exec(ua) || [];
+        return { name: 'ie', version: (tem[1] || '') };
+    }
+    if (M[1] === 'Chrome') {
+        tem = ua.match(/\bOPR|Edge\/(\d+)/);
+
+        if (tem != null) {
+            let version = tem[1];
+            if (!version) {
+                const splits = ua.split(tem[0] + '/');
+                if (splits.length > 1) {
+                    version = splits[1];
+                }
+            }
+
+            return { name: 'opera', version };
+        }
+    }
+    M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?'];
+    if ((tem = ua.match(/version\/(\d+)/i)) != null) { M.splice(1, 1, tem[1]); }
+    return {
+        name: M[0].toLowerCase(),
+        version: M[1],
+    };
+}
+
+let keepAliveServiceWorkerTimeoutId = null;
+
+export const sleepAsync = (milliseconds) => {
+    return new Promise(resolve => timer.setTimeout(resolve, milliseconds));
+};
+
+const keepAlive = () => {
+    try {
+        const operatingSystem = getOperatingSystem(navigator);
+        const minSleepSeconds = operatingSystem.os === 'Android' ? 240 : 150;
+        const promise = fetch(`/OidcKeepAliveServiceWorker.json?minSleepSeconds=${minSleepSeconds}`);
+        promise.catch(error => { console.log(error); });
+        sleepAsync(minSleepSeconds * 1000).then(keepAlive);
+    } catch (error) { console.log(error); }
+};
+
+const isServiceWorkerProxyActiveAsync = () => {
+    return fetch('/OidcKeepAliveServiceWorker.json', {
+        headers: {
+            'oidc-vanilla': 'true',
+        },
+    }).then((response) => {
+        return response.statusText === 'oidc-service-worker';
+    }).catch(error => { console.log(error); });
+};
+
+export const excludeOs = (operatingSystem) => {
+    if (operatingSystem.os === 'iOS' && operatingSystem.osVersion.startsWith('12')) {
+        return true;
+    }
+    if (operatingSystem.os === 'Mac OS X' && operatingSystem.osVersion.startsWith('10_15_6')) {
+        return true;
+    }
+    return false;
+};
+
+const sendMessageAsync = (registration) => (data) => {
+    return new Promise(function(resolve, reject) {
+        const messageChannel = new MessageChannel();
+        messageChannel.port1.onmessage = function (event) {
+            if (event.data && event.data.error) {
+                reject(event.data.error);
+            } else {
+                resolve(event.data);
+            }
+        };
+        registration.active.postMessage(data, [messageChannel.port2]);
+    });
+};
+
+export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName) => {
+    if (typeof window === 'undefined' || typeof navigator === 'undefined' || !navigator.serviceWorker || !serviceWorkerRelativeUrl) {
+        return null;
+    }
+    const { name, version } = getBrowser();
+    if (name === 'chrome' && parseInt(version) < 90) {
+        return null;
+    }
+    if (name === 'opera') {
+        if (!version) {
+            return null;
+        }
+        if (parseInt(version.split('.')[0]) < 80) {
+            return null;
+        }
+    }
+    if (name === 'ie') {
+        return null;
+    }
+
+   const operatingSystem = getOperatingSystem(navigator);
+    if (excludeOs(operatingSystem)) {
+        return null;
+    }
+
+    const registration = await navigator.serviceWorker.register(serviceWorkerRelativeUrl);
+
+    try {
+        await navigator.serviceWorker.ready;
+    } catch (err) {
+        return null;
+    }
+
+    const unregisterAsync = async () => {
+        return await registration.unregister();
+    };
+
+    registration.addEventListener('updatefound', () => {
+        const newWorker = registration.installing;
+        newWorker.addEventListener('statechange', () => {
+            switch (newWorker.state) {
+                case 'installed':
+                    if (navigator.serviceWorker.controller) {
+                        registration.unregister().then(() => {
+                            window.location.reload();
+                        });
+                    }
+                    break;
+            }
+        });
+    });
+
+    const clearAsync = async (status) => {
+        return sendMessageAsync(registration)({ type: 'clear', data: { status }, configurationName });
+    };
+    const initAsync = async (oidcServerConfiguration, where, oidcConfiguration:OidcConfiguration) => {
+        const result = await sendMessageAsync(registration)({
+            type: 'init',
+            data: {
+                oidcServerConfiguration,
+                where,
+                oidcConfiguration: {
+                    token_renew_mode: oidcConfiguration.token_renew_mode,
+                    service_worker_convert_all_requests_to_cors: oidcConfiguration.service_worker_convert_all_requests_to_cors,
+                },
+            },
+            configurationName,
+        });
+        // @ts-ignore
+        return { tokens: parseOriginalTokens(result.tokens, null, oidcConfiguration.token_renew_mode), status: result.status };
+    };
+
+    const startKeepAliveServiceWorker = () => {
+        if (keepAliveServiceWorkerTimeoutId == null) {
+            keepAliveServiceWorkerTimeoutId = 'not_null';
+            keepAlive();
+        }
+    };
+
+    const setSessionStateAsync = (sessionState:string) => {
+        return sendMessageAsync(registration)({ type: 'setSessionState', data: { sessionState }, configurationName });
+    };
+
+    const getSessionStateAsync = async () => {
+        const result = await sendMessageAsync(registration)({ type: 'getSessionState', data: null, configurationName });
+        // @ts-ignore
+        return result.sessionState;
+    };
+
+    const setNonceAsync = (nonce) => {
+        sessionStorage['oidc.nonce'] = nonce.nonce;
+        return sendMessageAsync(registration)({ type: 'setNonce', data: { nonce }, configurationName });
+    };
+  const getNonceAsync = async () => {
+        // @ts-ignore
+        const result = await sendMessageAsync(registration)({ type: 'getNonce', data: null, configurationName });
+        // @ts-ignore
+        let nonce = result.nonce;
+        if (!nonce) {
+            nonce = sessionStorage['oidc.nonce'];
+            console.warn('nonce not found in service worker, using sessionStorage');
+        }
+        return { nonce };
+    };
+
+    let getLoginParamsCache = null;
+    const setLoginParams = (configurationName:string, data) => {
+        getLoginParamsCache = data;
+        localStorage[`oidc.login.${configurationName}`] = JSON.stringify(data);
+    };
+    const getLoginParams = (configurationName) => {
+        const dataString = localStorage[`oidc.login.${configurationName}`];
+        if (!getLoginParamsCache) {
+            getLoginParamsCache = JSON.parse(dataString);
+        }
+        return getLoginParamsCache;
+    };
+
+    const getStateAsync = async () => {
+        const result = await sendMessageAsync(registration)({ type: 'getState', data: null, configurationName });
+        // @ts-ignore
+        let state = result.state;
+        if (!state) {
+            state = sessionStorage[`oidc.state.${configurationName}`];
+            console.warn('state not found in service worker, using sessionStorage');
+        }
+        return state;
+    };
+
+    const setStateAsync = async (state:string) => {
+        sessionStorage[`oidc.state.${configurationName}`] = state;
+        return sendMessageAsync(registration)({ type: 'setState', data: { state }, configurationName });
+    };
+
+    const getCodeVerifierAsync = async () => {
+        const result = await sendMessageAsync(registration)({ type: 'getCodeVerifier', data: null, configurationName });
+        // @ts-ignore
+        let codeVerifier = result.codeVerifier;
+        if (!codeVerifier) {
+            codeVerifier = sessionStorage[`oidc.code_verifier.${configurationName}`];
+            console.warn('codeVerifier not found in service worker, using sessionStorage');
+        }
+        return codeVerifier;
+    };
+
+    const setCodeVerifierAsync = async (codeVerifier:string) => {
+        sessionStorage[`oidc.code_verifier.${configurationName}`] = codeVerifier;
+        return sendMessageAsync(registration)({ type: 'setCodeVerifier', data: { codeVerifier }, configurationName });
+    };
+
+    return {
+        clearAsync,
+        initAsync,
+        startKeepAliveServiceWorker,
+        isServiceWorkerProxyActiveAsync,
+        setSessionStateAsync,
+        getSessionStateAsync,
+        setNonceAsync,
+        getNonceAsync,
+        unregisterAsync,
+        setLoginParams,
+        getLoginParams,
+        getStateAsync,
+        setStateAsync,
+        getCodeVerifierAsync,
+        setCodeVerifierAsync,
+    };
+};

package/src/login.ts

@@ -0,0 +1,174 @@
+import { generateRandom } from './crypto.js';
+import { eventNames } from './events.js';
+import { initSession } from './initSession.js';
+import { initWorkerAsync } from './initWorker.js';
+import { isTokensOidcValid } from './parseTokens.js';
+import { performAuthorizationRequestAsync, performFirstTokenRequestAsync } from './requests.js';
+import { getParseQueryStringFromLocation } from './route-utils.js';
+import { OidcConfiguration, StringMap } from './types.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export const defaultLoginAsync = (window, configurationName, configuration:OidcConfiguration, publishEvent :(string, any)=>void, initAsync:Function) => (callbackPath:string = undefined, extras:StringMap = null, isSilentSignin = false, scope:string = undefined) => {
+    const originExtras = extras;
+    extras = { ...extras };
+    const loginLocalAsync = async () => {
+        const location = window.location;
+        const url = callbackPath || location.pathname + (location.search || '') + (location.hash || '');
+
+        if (!('state' in extras)) {
+            extras.state = generateRandom(16);
+        }
+
+        publishEvent(eventNames.loginAsync_begin, {});
+        if (extras) {
+            for (const key of Object.keys(extras)) {
+                if (key.endsWith(':token_request')) {
+                    delete extras[key];
+                }
+            }
+        }
+        try {
+            const redirectUri = isSilentSignin ? configuration.silent_redirect_uri : configuration.redirect_uri;
+            if (!scope) {
+                scope = configuration.scope;
+            }
+
+            const extraFinal = !configuration.extras ? extras : { ...configuration.extras, ...extras };
+            if (!extraFinal.nonce) {
+                extraFinal.nonce = generateRandom(12);
+            }
+            const nonce = { nonce: extraFinal.nonce };
+            const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, configurationName);
+            const oidcServerConfiguration = await initAsync(configuration.authority, configuration.authority_configuration);
+            let storage;
+            if (serviceWorker) {
+                serviceWorker.setLoginParams(configurationName, { callbackPath: url, extras: originExtras });
+                serviceWorker.startKeepAliveServiceWorker();
+                await serviceWorker.initAsync(oidcServerConfiguration, 'loginAsync', configuration);
+                await serviceWorker.setNonceAsync(nonce);
+                storage = serviceWorker;
+            } else {
+                const session = initSession(configurationName, configuration.storage ?? sessionStorage);
+                session.setLoginParams(configurationName, { callbackPath: url, extras: originExtras });
+                await session.setNonceAsync(nonce);
+                storage = session;
+            }
+
+            // @ts-ignore
+            const extraInternal = {
+                client_id: configuration.client_id,
+                redirect_uri: redirectUri,
+                scope,
+                response_type: 'code',
+                ...extraFinal,
+            };
+            await performAuthorizationRequestAsync(storage)(oidcServerConfiguration.authorizationEndpoint, extraInternal);
+        } catch (exception) {
+            publishEvent(eventNames.loginAsync_error, exception);
+            throw exception;
+        }
+    };
+    return loginLocalAsync();
+};
+
+export const loginCallbackAsync = (oidc) => async (isSilentSignin = false) => {
+    try {
+        oidc.publishEvent(eventNames.loginCallbackAsync_begin, {});
+        const configuration = oidc.configuration;
+        const clientId = configuration.client_id;
+        const redirectUri = isSilentSignin ? configuration.silent_redirect_uri : configuration.redirect_uri;
+        const authority = configuration.authority;
+        const tokenRequestTimeout = configuration.token_request_timeout;
+        const oidcServerConfiguration = await oidc.initAsync(authority, configuration.authority_configuration);
+        const queryParams = getParseQueryStringFromLocation(window.location.href);
+        const sessionState = queryParams.session_state;
+        const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, oidc.configurationName);
+        let storage;
+        let nonceData;
+        let getLoginParams;
+        let state;
+        if (serviceWorker) {
+            serviceWorker.startKeepAliveServiceWorker();
+            await serviceWorker.initAsync(oidcServerConfiguration, 'loginCallbackAsync', configuration);
+            await serviceWorker.setSessionStateAsync(sessionState);
+            nonceData = await serviceWorker.getNonceAsync();
+            getLoginParams = serviceWorker.getLoginParams(oidc.configurationName);
+            state = await serviceWorker.getStateAsync();
+            storage = serviceWorker;
+        } else {
+            const session = initSession(oidc.configurationName, configuration.storage ?? sessionStorage);
+            await session.setSessionStateAsync(sessionState);
+            nonceData = await session.getNonceAsync();
+            getLoginParams = session.getLoginParams(oidc.configurationName);
+            state = await session.getStateAsync();
+            storage = session;
+        }
+
+        const params = getParseQueryStringFromLocation(window.location.toString());
+
+        if (params.iss && params.iss !== oidcServerConfiguration.issuer) {
+            throw new Error('issuer not valid');
+        }
+        if (params.state && params.state !== state) {
+            throw new Error('state not valid');
+        }
+
+        const data = {
+            code: params.code,
+            grant_type: 'authorization_code',
+            client_id: configuration.client_id,
+            redirect_uri: redirectUri,
+        };
+
+        const extras = {};
+        // @ts-ignore
+        if (configuration.token_request_extras) {
+            for (const [key, value] of Object.entries(configuration.token_request_extras)) {
+                extras[key] = value;
+            }
+        }
+        if (getLoginParams && getLoginParams.extras) {
+            for (const [key, value] of Object.entries(getLoginParams.extras)) {
+                if (key.endsWith(':token_request')) {
+                    extras[key.replace(':token_request', '')] = value;
+                }
+            }
+        }
+
+        const tokenResponse = await performFirstTokenRequestAsync(storage)(oidcServerConfiguration.tokenEndpoint, { ...data, ...extras }, oidc.configuration.token_renew_mode, tokenRequestTimeout);
+
+        if (!tokenResponse.success) {
+            throw new Error('Token request failed');
+        }
+
+        let loginParams;
+        const formattedTokens = tokenResponse.data.tokens;
+        if (serviceWorker) {
+            await serviceWorker.initAsync(redirectUri, 'syncTokensAsync', configuration);
+            loginParams = serviceWorker.getLoginParams(oidc.configurationName);
+        } else {
+            const session = initSession(oidc.configurationName, configuration.storage);
+            loginParams = session.getLoginParams(oidc.configurationName);
+        }
+        // @ts-ignore
+        if (tokenResponse.data.state !== extras.state) {
+            throw new Error('state is not valid');
+        }
+        const { isValid, reason } = isTokensOidcValid(formattedTokens, nonceData.nonce, oidcServerConfiguration);
+        if (!isValid) {
+            throw new Error(`Tokens are not OpenID valid, reason: ${reason}`);
+        }
+
+        await oidc.startCheckSessionAsync(oidcServerConfiguration.checkSessionIframe, clientId, sessionState, isSilentSignin);
+        oidc.publishEvent(eventNames.loginCallbackAsync_end, {});
+        return {
+            tokens: formattedTokens,
+            state: 'request.state',
+            callbackPath: loginParams.callbackPath,
+        };
+    } catch (exception) {
+        console.error(exception);
+        oidc.publishEvent(eventNames.loginCallbackAsync_error, exception);
+        throw exception;
+    }
+};

package/src/logout.spec.ts

@@ -0,0 +1,65 @@
+import '@testing-library/jest-dom';
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { logoutAsync } from "./logout";
+
+describe('Logout test suite', () => {
+
+    it.each([
+        {logout_tokens_to_invalidate:['access_token', 'refresh_token'], expectedResults: ["token=abcd&token_type_hint=access_token&client_id=interactive.public.short","token=abdc&token_type_hint=refresh_token&client_id=interactive.public.short"]}, 
+        {logout_tokens_to_invalidate:['refresh_token'], expectedResults: ["token=abdc&token_type_hint=refresh_token&client_id=interactive.public.short"]}, 
+        {logout_tokens_to_invalidate:['access_token'], expectedResults: ["token=abcd&token_type_hint=access_token&client_id=interactive.public.short"]}, 
+        {logout_tokens_to_invalidate:[], expectedResults: []}, 
+    ])('Logout should revoke tokens $logout_tokens_to_invalidate', async ({ logout_tokens_to_invalidate, expectedResults}) => {
+
+        const configuration = {
+            client_id: 'interactive.public.short',
+            redirect_uri: 'http://localhost:4200/authentication/callback',
+            scope: 'openid profile email api offline_access',
+            authority: 'http://api',
+            refresh_time_before_tokens_expiration_in_second: 70,
+            logout_tokens_to_invalidate,
+        };
+
+        const fetch = (url, data) => {
+            if(url === "http://api/connect/revocation") {
+                return Promise.resolve({status: 200});
+            }
+            return Promise.resolve({
+                status : 200,
+            });
+        };
+
+        const mockFetchFn = vi.fn().mockImplementation(fetch);
+        
+        const oidc = { 
+            configuration,
+            tokens : {idToken: "abcd", accessToken: "abcd", refreshToken: "abdc" }, 
+            initAsync: ()  => Promise.resolve({
+                revocationEndpoint: "http://api/connect/revocation",
+                endSessionEndpoint: "http://api/connect/endsession",
+            }),
+            destroyAsync: () => Promise.resolve(),
+            logoutSameTabAsync: () => Promise.resolve(),
+        };
+        
+        const oidcDatabase = {default: () => oidc};
+        
+        const window = {
+            location: {
+                href: "",
+                origin: "http://localhost:4200",
+            },
+        };
+
+        await logoutAsync(oidc, oidcDatabase, mockFetchFn, window, console)("/logged_out");
+        
+        // @ts-ignore
+
+        const results =  mockFetchFn.mock.calls.map((call, index) => call[1].body);
+    
+        expect(results).toEqual(expectedResults);
+        expect(window.location.href).toBe("http://api/connect/endsession?id_token_hint=abcd&post_logout_redirect_uri=http%3A%2F%2Flocalhost%3A4200%2Flogged_out");
+    });
+});

package/src/logout.ts

@@ -0,0 +1,101 @@
+import { initSession } from './initSession.js';
+import { initWorkerAsync } from './initWorker.js';
+import { performRevocationRequestAsync, TOKEN_TYPE } from './requests.js';
+import timer from './timer.js';
+import { StringMap } from './types.js';
+
+export const oidcLogoutTokens = {
+    access_token: 'access_token',
+    refresh_token: 'refresh_token',
+};
+
+export const destroyAsync = (oidc) => async (status) => {
+    timer.clearTimeout(oidc.timeoutId);
+    oidc.timeoutId = null;
+    if (oidc.checkSessionIFrame) {
+        oidc.checkSessionIFrame.stop();
+    }
+    const serviceWorker = await initWorkerAsync(oidc.configuration.service_worker_relative_url, oidc.configurationName);
+    if (!serviceWorker) {
+        const session = initSession(oidc.configurationName, oidc.configuration.storage);
+        await session.clearAsync(status);
+    } else {
+        await serviceWorker.clearAsync(status);
+    }
+    oidc.tokens = null;
+    oidc.userInfo = null;
+};
+
+export const logoutAsync = (oidc, oidcDatabase, fetch, window, console) => async (callbackPathOrUrl: string | null | undefined = undefined, extras: StringMap = null) => {
+    const configuration = oidc.configuration;
+    const oidcServerConfiguration = await oidc.initAsync(configuration.authority, configuration.authority_configuration);
+    if (callbackPathOrUrl && (typeof callbackPathOrUrl !== 'string')) {
+        callbackPathOrUrl = undefined;
+        console.warn('callbackPathOrUrl path is not a string');
+    }
+    const path = (callbackPathOrUrl === null || callbackPathOrUrl === undefined) ? location.pathname + (location.search || '') + (location.hash || '') : callbackPathOrUrl;
+    let isUri = false;
+    if (callbackPathOrUrl) {
+        isUri = callbackPathOrUrl.includes('https://') || callbackPathOrUrl.includes('http://');
+    }
+    const url = isUri ? callbackPathOrUrl : window.location.origin + path;
+    // @ts-ignore
+    const idToken = oidc.tokens ? oidc.tokens.idToken : '';
+    try {
+        const revocationEndpoint = oidcServerConfiguration.revocationEndpoint;
+        if (revocationEndpoint) {
+            const promises = [];
+            const accessToken = oidc.tokens.accessToken;
+            if (accessToken && configuration.logout_tokens_to_invalidate.includes(oidcLogoutTokens.access_token)) {
+                const revokeAccessTokenPromise = performRevocationRequestAsync(fetch)(revocationEndpoint, accessToken, TOKEN_TYPE.access_token, configuration.client_id);
+                promises.push(revokeAccessTokenPromise);
+            }
+            const refreshToken = oidc.tokens.refreshToken;
+            if (refreshToken && configuration.logout_tokens_to_invalidate.includes(oidcLogoutTokens.refresh_token)) {
+                const revokeRefreshTokenPromise = performRevocationRequestAsync(fetch)(revocationEndpoint, refreshToken, TOKEN_TYPE.refresh_token, configuration.client_id);
+                promises.push(revokeRefreshTokenPromise);
+            }
+            if (promises.length > 0) {
+                await Promise.all(promises);
+            }
+        }
+    } catch (exception) {
+        console.warn('logoutAsync: error when revoking tokens, if the error persist, you ay configure property logout_tokens_to_invalidate from configuration to avoid this error');
+        console.warn(exception);
+    }
+    // @ts-ignore
+    const sub = oidc.tokens && oidc.tokens.idTokenPayload ? oidc.tokens.idTokenPayload.sub : null;
+    await oidc.destroyAsync('LOGGED_OUT');
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const [key, itemOidc] of Object.entries(oidcDatabase)) {
+        if (itemOidc !== oidc) {
+            // @ts-ignore
+            await oidc.logoutSameTabAsync(oidc.configuration.client_id, sub);
+        }
+    }
+
+    if (oidcServerConfiguration.endSessionEndpoint) {
+        if (!extras) {
+            extras = {
+                id_token_hint: idToken,
+            };
+            if (callbackPathOrUrl !== null) {
+                extras.post_logout_redirect_uri = url;
+            }
+        }
+        let queryString = '';
+        if (extras) {
+            for (const [key, value] of Object.entries(extras)) {
+                if (queryString === '') {
+                    queryString += '?';
+                } else {
+                    queryString += '&';
+                }
+                queryString += `${key}=${encodeURIComponent(value)}`;
+            }
+        }
+        window.location.href = `${oidcServerConfiguration.endSessionEndpoint}${queryString}`;
+    } else {
+        window.location.reload();
+    }
+};