@axa-fr/react-oidc 6.11.4-alpha2 → 6.12.0

package/dist/vanilla/oidc.js

@@ -14,19 +14,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Oidc = exports.OidcAuthorizationServiceConfiguration = void 0;
 const appauth_1 = require("@openid/appauth");
-const checkSession_1 = require("./checkSession");
-const events_1 = require("./events");
+const cache_1 = require("./cache");
+const checkSessionIFrame_1 = require("./checkSessionIFrame");
 const initSession_1 = require("./initSession");
 const initWorker_1 = require("./initWorker");
-const login_1 = require("./login");
 const memoryStorageBackend_1 = require("./memoryStorageBackend");
 const noHashQueryStringUtils_1 = require("./noHashQueryStringUtils");
 const parseTokens_1 = require("./parseTokens");
 const requests_1 = require("./requests");
 const route_utils_1 = require("./route-utils");
-const silentLogin_1 = __importDefault(require("./silentLogin"));
 const timer_1 = __importDefault(require("./timer"));
-const user_1 = require("./user");
+const randomString = function (length) {
+    let text = '';
+    const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    for (let i = 0; i < length; i++) {
+        text += possible.charAt(Math.floor(Math.random() * possible.length));
+    }
+    return text;
+};
 class OidcAuthorizationServiceConfiguration extends appauth_1.AuthorizationServiceConfiguration {
     constructor(request) {
         super(request);
@@ -56,9 +61,9 @@ function renewTokensAndStartTimerAsync(oidc, refreshToken, forceRefresh = false,
     return __awaiter(this, void 0, void 0, function* () {
         const updateTokens = (tokens) => { oidc.tokens = tokens; };
         const { tokens, status } = yield oidc.synchroniseTokensAsync(refreshToken, 0, forceRefresh, extras, updateTokens);
-        const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(oidc.configuration.service_worker_relative_url, oidc.configurationName);
+        const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(oidc.configuration.service_worker_relative_url, oidc.configurationName, oidc.configuration.redirect_uri);
         if (!serviceWorker) {
-            const session = (0, initSession_1.initSession)(oidc.configurationName, oidc.configuration.storage);
+            const session = (0, initSession_1.initSession)(oidc.configurationName, oidc.configuration.redirect_uri, oidc.configuration.storage);
             yield session.setTokens(oidc.tokens);
         }
         if (!oidc.tokens) {
@@ -79,9 +84,85 @@ const autoRenewTokens = (oidc, refreshToken, expiresAt, extras = null) => {
         yield renewTokensAndStartTimerAsync(oidc, refreshToken, false, extras);
     }), 1000);
 };
+const userInfoAsync = (oidc) => __awaiter(void 0, void 0, void 0, function* () {
+    if (oidc.userInfo != null) {
+        return oidc.userInfo;
+    }
+    if (!oidc.tokens) {
+        return null;
+    }
+    const accessToken = oidc.tokens.accessToken;
+    if (!accessToken) {
+        return null;
+    }
+    // We wait the synchronisation before making a request
+    while (oidc.tokens && !(0, parseTokens_1.isTokensValid)(oidc.tokens)) {
+        yield (0, initWorker_1.sleepAsync)(200);
+    }
+    const oidcServerConfiguration = yield oidc.initAsync(oidc.configuration.authority, oidc.configuration.authority_configuration);
+    const url = oidcServerConfiguration.userInfoEndpoint;
+    const fetchUserInfo = (accessToken) => __awaiter(void 0, void 0, void 0, function* () {
+        const res = yield fetch(url, {
+            headers: {
+                authorization: `Bearer ${accessToken}`,
+            },
+        });
+        if (res.status !== 200) {
+            return null;
+        }
+        return res.json();
+    });
+    const userInfo = yield fetchUserInfo(accessToken);
+    oidc.userInfo = userInfo;
+    return userInfo;
+});
+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',
+    loginAsync_error: 'loginAsync_error',
+    loginCallbackAsync_begin: 'loginCallbackAsync_begin',
+    loginCallbackAsync_end: 'loginCallbackAsync_end',
+    loginCallbackAsync_error: 'loginCallbackAsync_error',
+    refreshTokensAsync_begin: 'refreshTokensAsync_begin',
+    refreshTokensAsync: 'refreshTokensAsync',
+    refreshTokensAsync_end: 'refreshTokensAsync_end',
+    refreshTokensAsync_error: 'refreshTokensAsync_error',
+    refreshTokensAsync_silent_error: 'refreshTokensAsync_silent_error',
+    tryKeepExistingSessionAsync_begin: 'tryKeepExistingSessionAsync_begin',
+    tryKeepExistingSessionAsync_end: 'tryKeepExistingSessionAsync_end',
+    tryKeepExistingSessionAsync_error: 'tryKeepExistingSessionAsync_error',
+    silentLoginAsync_begin: 'silentLoginAsync_begin',
+    silentLoginAsync: 'silentLoginAsync',
+    silentLoginAsync_end: 'silentLoginAsync_end',
+    silentLoginAsync_error: 'silentLoginAsync_error',
+    syncTokensAsync_begin: 'syncTokensAsync_begin',
+    syncTokensAsync_end: 'syncTokensAsync_end',
+    syncTokensAsync_error: 'syncTokensAsync_error',
+};
 const getRandomInt = (max) => {
     return Math.floor(Math.random() * max);
 };
+const oneHourSecond = 60 * 60;
+const fetchFromIssuer = (openIdIssuerUrl, timeCacheSecond = oneHourSecond, storage = window.sessionStorage) => __awaiter(void 0, void 0, void 0, function* () {
+    const fullUrl = `${openIdIssuerUrl}/.well-known/openid-configuration`;
+    const localStorageKey = `oidc.server:${openIdIssuerUrl}`;
+    const data = (0, cache_1.getFromCache)(localStorageKey, storage, timeCacheSecond);
+    if (data) {
+        return new OidcAuthorizationServiceConfiguration(data);
+    }
+    const response = yield fetch(fullUrl);
+    if (response.status !== 200) {
+        return null;
+    }
+    const result = yield response.json();
+    (0, cache_1.setCache)(localStorageKey, result, storage);
+    return new OidcAuthorizationServiceConfiguration(result);
+});
 class Oidc {
     constructor(configuration, configurationName = 'default') {
         var _a, _b, _c, _d;
@@ -165,7 +246,94 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
     }
     silentLoginAsync(extras = null, state = null, scope = null) {
         return __awaiter(this, void 0, void 0, function* () {
-            return (0, silentLogin_1.default)(this.configurationName, this.configuration, this.publishEvent.bind(this))(extras, state, scope);
+            if (!this.configuration.silent_redirect_uri || !this.configuration.silent_login_uri) {
+                return Promise.resolve(null);
+            }
+            try {
+                this.publishEvent(eventNames.silentLoginAsync_begin, {});
+                const configuration = this.configuration;
+                let queries = '';
+                if (state) {
+                    if (extras == null) {
+                        extras = {};
+                    }
+                    extras.state = state;
+                }
+                if (scope) {
+                    if (extras == null) {
+                        extras = {};
+                    }
+                    extras.scope = scope;
+                }
+                if (extras != null) {
+                    for (const [key, value] of Object.entries(extras)) {
+                        if (queries === '') {
+                            queries = `?${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+                        }
+                        else {
+                            queries += `&${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+                        }
+                    }
+                }
+                const link = configuration.silent_login_uri + queries;
+                const idx = link.indexOf('/', link.indexOf('//') + 2);
+                const iFrameOrigin = link.substr(0, idx);
+                const iframe = document.createElement('iframe');
+                iframe.width = '0px';
+                iframe.height = '0px';
+                iframe.id = `${this.configurationName}_oidc_iframe`;
+                iframe.setAttribute('src', link);
+                document.body.appendChild(iframe);
+                return new Promise((resolve, reject) => {
+                    try {
+                        let isResolved = false;
+                        window.onmessage = (e) => {
+                            if (e.origin === iFrameOrigin &&
+                                e.source === iframe.contentWindow) {
+                                const key = `${this.configurationName}_oidc_tokens:`;
+                                const key_error = `${this.configurationName}_oidc_error:`;
+                                const data = e.data;
+                                if (data && typeof (data) === 'string') {
+                                    if (!isResolved) {
+                                        if (data.startsWith(key)) {
+                                            const result = JSON.parse(e.data.replace(key, ''));
+                                            this.publishEvent(eventNames.silentLoginAsync_end, {});
+                                            iframe.remove();
+                                            isResolved = true;
+                                            resolve(result);
+                                        }
+                                        else if (data.startsWith(key_error)) {
+                                            const result = JSON.parse(e.data.replace(key_error, ''));
+                                            this.publishEvent(eventNames.silentLoginAsync_error, result);
+                                            iframe.remove();
+                                            isResolved = true;
+                                            reject(new Error('oidc_' + result.error));
+                                        }
+                                    }
+                                }
+                            }
+                        };
+                        const silentSigninTimeout = configuration.silent_login_timeout;
+                        setTimeout(() => {
+                            if (!isResolved) {
+                                this.publishEvent(eventNames.silentLoginAsync_error, { reason: 'timeout' });
+                                iframe.remove();
+                                isResolved = true;
+                                reject(new Error('timeout'));
+                            }
+                        }, silentSigninTimeout);
+                    }
+                    catch (e) {
+                        iframe.remove();
+                        this.publishEvent(eventNames.silentLoginAsync_error, e);
+                        reject(e);
+                    }
+                });
+            }
+            catch (e) {
+                this.publishEvent(eventNames.silentLoginAsync_error, e);
+                throw e;
+            }
         });
     }
     initAsync(authority, authorityConfiguration) {
@@ -186,9 +354,9 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         issuer: authorityConfiguration.issuer,
                     });
                 }
-                const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(this.configuration.service_worker_relative_url, this.configurationName);
+                const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(this.configuration.service_worker_relative_url, this.configurationName, this.configuration.redirect_uri);
                 const storage = serviceWorker ? window.localStorage : null;
-                return yield (0, requests_1.fetchFromIssuer)(authority, (_a = this.configuration.authority_time_cache_wellknowurl_in_second) !== null && _a !== void 0 ? _a : 60 * 60, storage);
+                return yield fetchFromIssuer(authority, (_a = this.configuration.authority_time_cache_wellknowurl_in_second) !== null && _a !== void 0 ? _a : 60 * 60, storage);
             });
             this.initPromise = localFuncAsync();
             return this.initPromise.then((result) => {
@@ -208,11 +376,11 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 if (this.tokens != null) {
                     return false;
                 }
-                this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_begin, {});
+                this.publishEvent(eventNames.tryKeepExistingSessionAsync_begin, {});
                 try {
                     const configuration = this.configuration;
                     const oidcServerConfiguration = yield this.initAsync(configuration.authority, configuration.authority_configuration);
-                    serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, this.configurationName);
+                    serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, this.configurationName, configuration.redirect_uri);
                     if (serviceWorker) {
                         const { tokens } = yield serviceWorker.initAsync(oidcServerConfiguration, 'tryKeepExistingSessionAsync', configuration);
                         if (tokens) {
@@ -224,24 +392,24 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                             const sessionState = yield serviceWorker.getSessionStateAsync();
                             // @ts-ignore
                             yield this.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, configuration.client_id, sessionState);
-                            this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_end, {
+                            this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
                                 success: true,
                                 message: 'tokens inside ServiceWorker are valid',
                             });
                             return true;
                         }
-                        this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_end, {
+                        this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
                             success: false,
                             message: 'no exiting session found',
                         });
                     }
                     else {
                         if (configuration.service_worker_relative_url) {
-                            this.publishEvent(events_1.eventNames.service_worker_not_supported_by_browser, {
+                            this.publishEvent(eventNames.service_worker_not_supported_by_browser, {
                                 message: 'service worker is not supported by this browser',
                             });
                         }
-                        const session = (0, initSession_1.initSession)(this.configurationName, (_a = configuration.storage) !== null && _a !== void 0 ? _a : sessionStorage);
+                        const session = (0, initSession_1.initSession)(this.configurationName, configuration.redirect_uri, (_a = configuration.storage) !== null && _a !== void 0 ? _a : sessionStorage);
                         const { tokens } = yield session.initAsync();
                         if (tokens) {
                             // @ts-ignore
@@ -251,14 +419,14 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                             const sessionState = session.getSessionState();
                             // @ts-ignore
                             yield this.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, configuration.client_id, sessionState);
-                            this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_end, {
+                            this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
                                 success: true,
                                 message: 'tokens inside storage are valid',
                             });
                             return true;
                         }
                     }
-                    this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_end, {
+                    this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
                         success: false,
                         message: serviceWorker ? 'service worker sessions not retrieved' : 'session storage sessions not retrieved',
                     });
@@ -269,7 +437,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     if (serviceWorker) {
                         yield serviceWorker.clearAsync();
                     }
-                    this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_error, 'tokens inside ServiceWorker are invalid');
+                    this.publishEvent(eventNames.tryKeepExistingSessionAsync_error, 'tokens inside ServiceWorker are invalid');
                     return false;
                 }
             });
@@ -280,27 +448,145 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             });
         });
     }
-    startCheckSessionAsync(checkSessionIFrameUri, clientId, sessionState, isSilentSignin = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const getCurrentTokens = () => this.tokens;
-            this.checkSessionIFrame = yield (0, checkSession_1.startCheckSessionAsync)(oidcDatabase, this.configuration, this.checkSessionIFrame, this.silentLoginAsync.bind(this), getCurrentTokens)(checkSessionIFrameUri, clientId, sessionState, isSilentSignin);
-        });
-    }
     loginAsync(callbackPath = undefined, extras = null, isSilentSignin = false, scope = undefined, silentLoginOnly = false) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.loginPromise !== null) {
                 return this.loginPromise;
             }
-            if (silentLoginOnly) {
-                return (0, login_1.defaultSilentLoginAsync2)(window, this.configurationName, this.configuration, this.publishEvent.bind(this), this)(extras, scope);
-            }
-            this.loginPromise = (0, login_1.defaultLoginAsync)(window, this.configurationName, this.configuration, this.silentLoginAsync.bind(this), this.publishEvent.bind(this), this.initAsync.bind(this))(callbackPath, extras, isSilentSignin, scope);
+            const loginLocalAsync = () => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const location = window.location;
+                const url = callbackPath || location.pathname + (location.search || '') + (location.hash || '');
+                const configuration = this.configuration;
+                let state;
+                if (extras && 'state' in extras) {
+                    state = extras.state;
+                    delete extras.state;
+                }
+                if (silentLoginOnly) {
+                    try {
+                        const extraFinal = (_a = extras !== null && extras !== void 0 ? extras : configuration.extras) !== null && _a !== void 0 ? _a : {};
+                        const silentResult = yield this.silentLoginAsync(Object.assign(Object.assign({}, extraFinal), { prompt: 'none' }), state, scope);
+                        if (silentResult) {
+                            this.tokens = silentResult.tokens;
+                            this.publishEvent(eventNames.token_aquired, {});
+                            // @ts-ignore
+                            this.timeoutId = autoRenewTokens(this, this.tokens.refreshToken, this.tokens.expiresAt, extras);
+                            return {};
+                        }
+                    }
+                    catch (e) {
+                        return e;
+                    }
+                }
+                this.publishEvent(eventNames.loginAsync_begin, {});
+                try {
+                    const redirectUri = isSilentSignin ? configuration.silent_redirect_uri : configuration.redirect_uri;
+                    if (!scope) {
+                        scope = configuration.scope;
+                    }
+                    const extraFinal = (_b = extras !== null && extras !== void 0 ? extras : configuration.extras) !== null && _b !== void 0 ? _b : {};
+                    if (!extraFinal.nonce) {
+                        extraFinal.nonce = randomString(12);
+                    }
+                    const nonce = { nonce: extraFinal.nonce };
+                    const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, this.configurationName, this.configuration.redirect_uri);
+                    const oidcServerConfiguration = yield this.initAsync(configuration.authority, configuration.authority_configuration);
+                    let storage;
+                    if (serviceWorker) {
+                        serviceWorker.setLoginParams(this.configurationName, redirectUri, { callbackPath: url, extras, state });
+                        serviceWorker.startKeepAliveServiceWorker();
+                        yield serviceWorker.initAsync(oidcServerConfiguration, 'loginAsync', configuration);
+                        yield serviceWorker.setNonceAsync(nonce);
+                        storage = new memoryStorageBackend_1.MemoryStorageBackend(serviceWorker.saveItemsAsync, {});
+                        yield storage.setItem('dummy', {});
+                    }
+                    else {
+                        const session = (0, initSession_1.initSession)(this.configurationName, redirectUri);
+                        session.setLoginParams(this.configurationName, redirectUri, { callbackPath: url, extras, state });
+                        yield session.setNonceAsync(nonce);
+                        storage = new memoryStorageBackend_1.MemoryStorageBackend(session.saveItemsAsync, {});
+                    }
+                    // @ts-ignore
+                    const queryStringUtil = redirectUri.includes('#') ? new noHashQueryStringUtils_1.HashQueryStringUtils() : new noHashQueryStringUtils_1.NoHashQueryStringUtils();
+                    const authorizationHandler = new appauth_1.RedirectRequestHandler(storage, queryStringUtil, window.location, new appauth_1.DefaultCrypto());
+                    const authRequest = new appauth_1.AuthorizationRequest({
+                        client_id: configuration.client_id,
+                        redirect_uri: redirectUri,
+                        scope,
+                        response_type: appauth_1.AuthorizationRequest.RESPONSE_TYPE_CODE,
+                        state,
+                        extras: extraFinal,
+                    });
+                    authorizationHandler.performAuthorizationRequest(oidcServerConfiguration, authRequest);
+                }
+                catch (exception) {
+                    this.publishEvent(eventNames.loginAsync_error, exception);
+                    throw exception;
+                }
+            });
+            this.loginPromise = loginLocalAsync();
             return this.loginPromise.then(result => {
                 this.loginPromise = null;
                 return result;
             });
         });
     }
+    startCheckSessionAsync(checkSessionIFrameUri, clientId, sessionState, isSilentSignin = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                if (this.configuration.silent_login_uri && this.configuration.silent_redirect_uri && this.configuration.monitor_session && checkSessionIFrameUri && sessionState && !isSilentSignin) {
+                    const checkSessionCallback = () => {
+                        this.checkSessionIFrame.stop();
+                        if (this.tokens === null) {
+                            return;
+                        }
+                        // @ts-ignore
+                        const idToken = this.tokens.idToken;
+                        // @ts-ignore
+                        const idTokenPayload = this.tokens.idTokenPayload;
+                        this.silentLoginAsync({
+                            prompt: 'none',
+                            id_token_hint: idToken,
+                            scope: 'openid',
+                        }).then((silentSigninResponse) => {
+                            const iFrameIdTokenPayload = silentSigninResponse.tokens.idTokenPayload;
+                            if (idTokenPayload.sub === iFrameIdTokenPayload.sub) {
+                                const sessionState = silentSigninResponse.sessionState;
+                                this.checkSessionIFrame.start(silentSigninResponse.sessionState);
+                                if (idTokenPayload.sid === iFrameIdTokenPayload.sid) {
+                                    console.debug('SessionMonitor._callback: Same sub still logged in at OP, restarting check session iframe; session_state:', sessionState);
+                                }
+                                else {
+                                    console.debug('SessionMonitor._callback: Same sub still logged in at OP, session state has changed, restarting check session iframe; session_state:', sessionState);
+                                }
+                            }
+                            else {
+                                console.debug('SessionMonitor._callback: Different subject signed into OP:', iFrameIdTokenPayload.sub);
+                            }
+                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        }).catch((e) => __awaiter(this, void 0, void 0, function* () {
+                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                            for (const [key, oidc] of Object.entries(oidcDatabase)) {
+                                // @ts-ignore
+                                yield oidc.logoutOtherTabAsync(this.configuration.client_id, idTokenPayload.sub);
+                            }
+                        }));
+                    };
+                    this.checkSessionIFrame = new checkSessionIFrame_1.CheckSessionIFrame(checkSessionCallback, clientId, checkSessionIFrameUri);
+                    this.checkSessionIFrame.load().then(() => {
+                        this.checkSessionIFrame.start(sessionState);
+                        resolve();
+                    }).catch((e) => {
+                        reject(e);
+                    });
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
     loginCallbackAsync(isSilenSignin = false) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.loginCallbackPromise !== null) {
@@ -312,9 +598,9 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 const parsedTokens = response.tokens;
                 // @ts-ignore
                 this.tokens = response.tokens;
-                const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(this.configuration.service_worker_relative_url, this.configurationName);
+                const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(this.configuration.service_worker_relative_url, this.configurationName, this.configuration.redirect_uri);
                 if (!serviceWorker) {
-                    const session = (0, initSession_1.initSession)(this.configurationName, this.configuration.storage);
+                    const session = (0, initSession_1.initSession)(this.configurationName, this.configuration.redirect_uri, this.configuration.storage);
                     session.setTokens(parsedTokens);
                 }
                 this.publishEvent(Oidc.eventNames.token_aquired, parsedTokens);
@@ -331,7 +617,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
     _loginCallbackAsync(isSilentSignin = false) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                this.publishEvent(events_1.eventNames.loginCallbackAsync_begin, {});
+                this.publishEvent(eventNames.loginCallbackAsync_begin, {});
                 const configuration = this.configuration;
                 const clientId = configuration.client_id;
                 const redirectUri = isSilentSignin ? configuration.silent_redirect_uri : configuration.redirect_uri;
@@ -340,10 +626,9 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 const oidcServerConfiguration = yield this.initAsync(authority, configuration.authority_configuration);
                 const queryParams = (0, route_utils_1.getParseQueryStringFromLocation)(window.location.href);
                 const sessionState = queryParams.session_state;
-                const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, this.configurationName);
+                const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, this.configurationName, configuration.redirect_uri);
                 let storage = null;
                 let nonceData = null;
-                let getLoginParams = null;
                 if (serviceWorker) {
                     serviceWorker.startKeepAliveServiceWorker();
                     yield serviceWorker.initAsync(oidcServerConfiguration, 'loginCallbackAsync', configuration);
@@ -356,15 +641,13 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     yield storage.removeItem('dummy');
                     yield serviceWorker.setSessionStateAsync(sessionState);
                     nonceData = yield serviceWorker.getNonceAsync();
-                    getLoginParams = serviceWorker.getLoginParams(this.configurationName);
                 }
                 else {
-                    const session = (0, initSession_1.initSession)(this.configurationName);
+                    const session = (0, initSession_1.initSession)(this.configurationName, redirectUri);
                     session.setSessionState(sessionState);
                     const items = yield session.loadItemsAsync();
                     storage = new memoryStorageBackend_1.MemoryStorageBackend(session.saveItemsAsync, items);
                     nonceData = yield session.getNonceAsync();
-                    getLoginParams = session.getLoginParams(this.configurationName);
                 }
                 return new Promise((resolve, reject) => {
                     let queryStringUtil = new noHashQueryStringUtils_1.NoHashQueryStringUtils();
@@ -378,7 +661,6 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     const notifier = new appauth_1.AuthorizationNotifier();
                     authorizationHandler.setAuthorizationNotifier(notifier);
                     notifier.setAuthorizationListener((request, response, error) => {
-                        var _a;
                         if (error) {
                             reject(error);
                             return;
@@ -387,27 +669,20 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                             reject(new Error('no response'));
                             return;
                         }
-                        const extras = {};
+                        let extras = null;
                         if (request && request.internal) {
-                            // @ts-ignore
+                            extras = {};
                             extras.code_verifier = request.internal.code_verifier;
                             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 tokenRequest = new appauth_1.TokenRequest({
                             client_id: clientId,
                             redirect_uri: redirectUri,
-                            grant_type: (_a = extras.grant_type) !== null && _a !== void 0 ? _a : appauth_1.GRANT_TYPE_AUTHORIZATION_CODE,
+                            grant_type: appauth_1.GRANT_TYPE_AUTHORIZATION_CODE,
                             code: response.code,
                             refresh_token: undefined,
                             extras,
@@ -426,12 +701,12 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                                     let formattedTokens = null;
                                     if (serviceWorker) {
                                         const { tokens } = yield serviceWorker.initAsync(oidcServerConfiguration, 'syncTokensAsync', configuration);
-                                        loginParams = serviceWorker.getLoginParams(this.configurationName);
+                                        loginParams = serviceWorker.getLoginParams(this.configurationName, redirectUri);
                                         formattedTokens = tokens;
                                     }
                                     else {
-                                        const session = (0, initSession_1.initSession)(this.configurationName, configuration.storage);
-                                        loginParams = session.getLoginParams(this.configurationName);
+                                        const session = (0, initSession_1.initSession)(this.configurationName, redirectUri, configuration.storage);
+                                        loginParams = session.getLoginParams(this.configurationName, redirectUri);
                                         formattedTokens = (0, parseTokens_1.setTokens)(tokenResponse, null, configuration.token_renew_mode);
                                     }
                                     if (!(0, parseTokens_1.isTokensOidcValid)(formattedTokens, nonceData.nonce, oidcServerConfiguration)) {
@@ -439,13 +714,13 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                                         if (timeoutId) {
                                             clearTimeout(timeoutId);
                                             this.timeoutId = null;
-                                            this.publishEvent(events_1.eventNames.loginCallbackAsync_error, exception);
+                                            this.publishEvent(eventNames.loginCallbackAsync_error, exception);
                                             console.error(exception);
                                             reject(exception);
                                         }
                                     }
                                     this.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, clientId, sessionState, isSilentSignin).then(() => {
-                                        this.publishEvent(events_1.eventNames.loginCallbackAsync_end, {});
+                                        this.publishEvent(eventNames.loginCallbackAsync_end, {});
                                         resolve({
                                             tokens: formattedTokens,
                                             state: request.state,
@@ -459,7 +734,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                             if (timeoutId) {
                                 clearTimeout(timeoutId);
                                 this.timeoutId = null;
-                                this.publishEvent(events_1.eventNames.loginCallbackAsync_error, exception);
+                                this.publishEvent(eventNames.loginCallbackAsync_error, exception);
                                 console.error(exception);
                                 reject(exception);
                             }
@@ -470,7 +745,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             }
             catch (exception) {
                 console.error(exception);
-                this.publishEvent(events_1.eventNames.loginCallbackAsync_error, exception);
+                this.publishEvent(eventNames.loginCallbackAsync_error, exception);
                 throw exception;
             }
         });
@@ -479,19 +754,19 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         return __awaiter(this, void 0, void 0, function* () {
             while (!navigator.onLine && document.hidden) {
                 yield (0, initWorker_1.sleepAsync)(1000);
-                this.publishEvent(events_1.eventNames.refreshTokensAsync, { message: 'wait because navigator is offline and hidden' });
+                this.publishEvent(eventNames.refreshTokensAsync, { message: 'wait because navigator is offline and hidden' });
             }
             let numberTryOnline = 6;
             while (!navigator.onLine && numberTryOnline > 0) {
                 yield (0, initWorker_1.sleepAsync)(1000);
                 numberTryOnline--;
-                this.publishEvent(events_1.eventNames.refreshTokensAsync, { message: `wait because navigator is offline try ${numberTryOnline}` });
+                this.publishEvent(eventNames.refreshTokensAsync, { message: `wait because navigator is offline try ${numberTryOnline}` });
             }
             let numberTryHidden = Math.floor(Math.random() * 15) + 10;
             while (document.hidden && numberTryHidden > 0) {
                 yield (0, initWorker_1.sleepAsync)(1000);
                 numberTryHidden--;
-                this.publishEvent(events_1.eventNames.refreshTokensAsync, { message: `wait because navigator is hidden try ${numberTryHidden}` });
+                this.publishEvent(eventNames.refreshTokensAsync, { message: `wait because navigator is hidden try ${numberTryHidden}` });
             }
             const isDocumentHidden = document.hidden;
             const nextIndex = isDocumentHidden ? index : index + 1;
@@ -502,13 +777,13 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             const localsilentLoginAsync = () => __awaiter(this, void 0, void 0, function* () {
                 try {
                     let loginParams = null;
-                    const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, this.configurationName);
+                    const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, this.configurationName, configuration.redirect_uri);
                     if (serviceWorker) {
-                        loginParams = serviceWorker.getLoginParams(this.configurationName);
+                        loginParams = serviceWorker.getLoginParams(this.configurationName, configuration.redirect_uri);
                     }
                     else {
-                        const session = (0, initSession_1.initSession)(this.configurationName, configuration.storage);
-                        loginParams = session.getLoginParams(this.configurationName);
+                        const session = (0, initSession_1.initSession)(this.configurationName, configuration.redirect_uri, configuration.storage);
+                        loginParams = session.getLoginParams(this.configurationName, configuration.redirect_uri);
                     }
                     const silent_token_response = yield this.silentLoginAsync(Object.assign(Object.assign(Object.assign({}, loginParams.extras), extras), { prompt: 'none' }), loginParams.state);
                     if (silent_token_response) {
@@ -519,18 +794,18 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 }
                 catch (exceptionSilent) {
                     console.error(exceptionSilent);
-                    this.publishEvent(events_1.eventNames.refreshTokensAsync_silent_error, { message: 'exceptionSilent', exception: exceptionSilent.message });
+                    this.publishEvent(eventNames.refreshTokensAsync_silent_error, { message: 'exceptionSilent', exception: exceptionSilent.message });
                     if (exceptionSilent && exceptionSilent.message && exceptionSilent.message.startsWith('oidc')) {
                         updateTokens(null);
-                        this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token silent' });
+                        this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token silent' });
                         return { tokens: null, status: 'SESSION_LOST' };
                     }
                 }
-                this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token silent return' });
+                this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token silent return' });
                 return yield this.synchroniseTokensAsync(null, nextIndex, forceRefresh, extras, updateTokens);
             });
             if (index > 4) {
-                this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token' });
+                this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token' });
                 return { tokens: null, status: 'SESSION_LOST' };
             }
             try {
@@ -538,7 +813,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 switch (status) {
                     case 'SESSION_LOST':
                         updateTokens(null);
-                        this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token session lost' });
+                        this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token session lost' });
                         return { tokens: null, status: 'SESSION_LOST' };
                     case 'NOT_CONNECTED':
                         updateTokens(null);
@@ -552,13 +827,13 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         return { tokens, status: 'LOGGED_IN' };
                     case 'LOGOUT_FROM_ANOTHER_TAB':
                         updateTokens(null);
-                        this.publishEvent(events_1.eventNames.logout_from_another_tab, { status: 'session syncTokensAsync' });
+                        this.publishEvent(eventNames.logout_from_another_tab, { status: 'session syncTokensAsync' });
                         return { tokens: null, status: 'LOGGED_OUT' };
                     case 'REQUIRE_SYNC_TOKENS':
-                        this.publishEvent(events_1.eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
+                        this.publishEvent(eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
                         return yield localsilentLoginAsync();
                     default: {
-                        this.publishEvent(events_1.eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
+                        this.publishEvent(eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
                         if (!refreshToken) {
                             return yield localsilentLoginAsync();
                         }
@@ -580,16 +855,16 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                             if (tokenResponse.success) {
                                 if (!(0, parseTokens_1.isTokensOidcValid)(tokenResponse.data, nonce.nonce, oidcServerConfiguration)) {
                                     updateTokens(null);
-                                    this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token return not valid tokens' });
+                                    this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token return not valid tokens' });
                                     return { tokens: null, status: 'SESSION_LOST' };
                                 }
                                 updateTokens(tokenResponse.data);
-                                this.publishEvent(events_1.eventNames.refreshTokensAsync_end, { success: tokenResponse.success });
+                                this.publishEvent(eventNames.refreshTokensAsync_end, { success: tokenResponse.success });
                                 this.publishEvent(Oidc.eventNames.token_renewed, { reason: 'REFRESH_TOKEN' });
                                 return { tokens: tokenResponse.data, status: 'LOGGED_IN' };
                             }
                             else {
-                                this.publishEvent(events_1.eventNames.refreshTokensAsync_silent_error, {
+                                this.publishEvent(eventNames.refreshTokensAsync_silent_error, {
                                     message: 'bad request',
                                     tokenResponse,
                                 });
@@ -603,7 +878,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             }
             catch (exception) {
                 console.error(exception);
-                this.publishEvent(events_1.eventNames.refreshTokensAsync_silent_error, { message: 'exception', exception: exception.message });
+                this.publishEvent(eventNames.refreshTokensAsync_silent_error, { message: 'exception', exception: exception.message });
                 return this.synchroniseTokensAsync(refreshToken, nextIndex, forceRefresh, extras, updateTokens);
             }
         });
@@ -619,7 +894,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             }
             let nonce = nullNonce;
             const oidcServerConfiguration = yield this.initAsync(configuration.authority, configuration.authority_configuration);
-            const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, configurationName);
+            const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, configurationName, configuration.redirect_uri);
             if (serviceWorker) {
                 const { status, tokens } = yield serviceWorker.initAsync(oidcServerConfiguration, 'syncTokensAsync', configuration);
                 if (status === 'LOGGED_OUT') {
@@ -640,7 +915,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 nonce = yield serviceWorker.getNonceAsync();
             }
             else {
-                const session = (0, initSession_1.initSession)(configurationName, (_a = configuration.storage) !== null && _a !== void 0 ? _a : sessionStorage);
+                const session = (0, initSession_1.initSession)(configurationName, configuration.redirect_uri, (_a = configuration.storage) !== null && _a !== void 0 ? _a : sessionStorage);
                 const { tokens, status } = yield session.initAsync();
                 if (!tokens) {
                     return { tokens: null, status: 'LOGOUT_FROM_ANOTHER_TAB', nonce: nullNonce };
@@ -678,7 +953,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         if (this.userInfoPromise !== null) {
             return this.userInfoPromise;
         }
-        this.userInfoPromise = (0, user_1.userInfoAsync)(this);
+        this.userInfoPromise = userInfoAsync(this);
         return this.userInfoPromise.then(result => {
             this.userInfoPromise = null;
             return result;
@@ -701,9 +976,9 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             if (this.checkSessionIFrame) {
                 this.checkSessionIFrame.stop();
             }
-            const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(this.configuration.service_worker_relative_url, this.configurationName);
+            const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(this.configuration.service_worker_relative_url, this.configurationName, this.configuration.redirect_uri);
             if (!serviceWorker) {
-                const session = (0, initSession_1.initSession)(this.configurationName, this.configuration.storage);
+                const session = (0, initSession_1.initSession)(this.configurationName, this.configuration.redirect_uri, this.configuration.storage);
                 yield session.clearAsync(status);
             }
             else {
@@ -718,7 +993,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         return __awaiter(this, void 0, void 0, function* () {
             // @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(events_1.eventNames.logout_from_same_tab, { message: sub });
+                this.publishEvent(eventNames.logout_from_same_tab, { message: sub });
                 yield this.destroyAsync('LOGGED_OUT');
             }
         });
@@ -728,7 +1003,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             // @ts-ignore
             if (this.configuration.monitor_session && this.configuration.client_id === clientId && sub && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === sub) {
                 yield this.destroyAsync('LOGGED_OUT');
-                this.publishEvent(events_1.eventNames.logout_from_another_tab, { message: 'SessionMonitor', sub });
+                this.publishEvent(eventNames.logout_from_another_tab, { message: 'SessionMonitor', sub });
             }
         });
     }
@@ -808,6 +1083,6 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
     }
 }
 exports.Oidc = Oidc;
-Oidc.eventNames = events_1.eventNames;
+Oidc.eventNames = eventNames;
 exports.default = Oidc;
 //# sourceMappingURL=oidc.js.map