@axa-fr/react-oidc 6.12.1 → 6.13.1

package/dist/vanilla/oidc.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -14,24 +37,18 @@ 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 cache_1 = require("./cache");
-const checkSessionIFrame_1 = require("./checkSessionIFrame");
+const checkSession_1 = require("./checkSession");
+const events_1 = require("./events");
 const initSession_1 = require("./initSession");
 const initWorker_1 = require("./initWorker");
-const memoryStorageBackend_1 = require("./memoryStorageBackend");
-const noHashQueryStringUtils_1 = require("./noHashQueryStringUtils");
+const login_1 = require("./login");
 const parseTokens_1 = require("./parseTokens");
+const renewTokens_1 = require("./renewTokens");
 const requests_1 = require("./requests");
 const route_utils_1 = require("./route-utils");
+const silentLogin_1 = __importStar(require("./silentLogin"));
 const timer_1 = __importDefault(require("./timer"));
-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;
-};
+const user_1 = require("./user");
 class OidcAuthorizationServiceConfiguration extends appauth_1.AuthorizationServiceConfiguration {
     constructor(request) {
         super(request);
@@ -54,115 +71,12 @@ const oidcFactory = (configuration, name = 'default') => {
 };
 const loginCallbackWithAutoTokensRenewAsync = (oidc) => __awaiter(void 0, void 0, void 0, function* () {
     const { parsedTokens, callbackPath } = yield oidc.loginCallbackAsync();
-    oidc.timeoutId = autoRenewTokens(oidc, parsedTokens.refreshToken, parsedTokens.expiresAt);
+    oidc.timeoutId = (0, renewTokens_1.autoRenewTokens)(oidc, parsedTokens.refreshToken, parsedTokens.expiresAt);
     return { callbackPath };
 });
-function renewTokensAndStartTimerAsync(oidc, refreshToken, forceRefresh = false, extras = null) {
-    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, oidc.configuration.redirect_uri);
-        if (!serviceWorker) {
-            const session = (0, initSession_1.initSession)(oidc.configurationName, oidc.configuration.redirect_uri, oidc.configuration.storage);
-            yield session.setTokens(oidc.tokens);
-        }
-        if (!oidc.tokens) {
-            yield oidc.destroyAsync(status);
-            return;
-        }
-        if (oidc.timeoutId) {
-            oidc.timeoutId = autoRenewTokens(oidc, tokens.refreshToken, oidc.tokens.expiresAt, extras);
-        }
-    });
-}
-const autoRenewTokens = (oidc, refreshToken, expiresAt, extras = null) => {
-    const refreshTimeBeforeTokensExpirationInSecond = oidc.configuration.refresh_time_before_tokens_expiration_in_second;
-    return timer_1.default.setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
-        const timeLeft = (0, parseTokens_1.computeTimeLeft)(refreshTimeBeforeTokensExpirationInSecond, expiresAt);
-        const timeInfo = { timeLeft };
-        oidc.publishEvent(Oidc.eventNames.token_timer, timeInfo);
-        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;
@@ -186,7 +100,6 @@ class Oidc {
         this.loginCallbackWithAutoTokensRenewAsync.bind(this);
         this.initAsync.bind(this);
         this.loginCallbackAsync.bind(this);
-        this._loginCallbackAsync.bind(this);
         this.subscribeEvents.bind(this);
         this.removeEventSubscription.bind(this);
         this.publishEvent.bind(this);
@@ -244,98 +157,6 @@ 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* () {
-            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) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.initPromise !== null) {
@@ -354,9 +175,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, this.configuration.redirect_uri);
+                const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(this.configuration.service_worker_relative_url, this.configurationName);
                 const storage = serviceWorker ? window.localStorage : null;
-                return yield fetchFromIssuer(authority, (_a = this.configuration.authority_time_cache_wellknowurl_in_second) !== null && _a !== void 0 ? _a : 60 * 60, storage);
+                return yield (0, requests_1.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) => {
@@ -376,57 +197,59 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 if (this.tokens != null) {
                     return false;
                 }
-                this.publishEvent(eventNames.tryKeepExistingSessionAsync_begin, {});
+                this.publishEvent(events_1.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, configuration.redirect_uri);
+                    serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, this.configurationName);
                     if (serviceWorker) {
                         const { tokens } = yield serviceWorker.initAsync(oidcServerConfiguration, 'tryKeepExistingSessionAsync', configuration);
                         if (tokens) {
                             serviceWorker.startKeepAliveServiceWorker();
                             // @ts-ignore
                             this.tokens = tokens;
+                            const getLoginParams = serviceWorker.getLoginParams(this.configurationName);
                             // @ts-ignore
-                            this.timeoutId = autoRenewTokens(this, this.tokens.refreshToken, this.tokens.expiresAt);
+                            this.timeoutId = (0, renewTokens_1.autoRenewTokens)(this, this.tokens.refreshToken, this.tokens.expiresAt, getLoginParams.extras);
                             const sessionState = yield serviceWorker.getSessionStateAsync();
                             // @ts-ignore
                             yield this.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, configuration.client_id, sessionState);
-                            this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
+                            this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_end, {
                                 success: true,
                                 message: 'tokens inside ServiceWorker are valid',
                             });
                             return true;
                         }
-                        this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
+                        this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_end, {
                             success: false,
                             message: 'no exiting session found',
                         });
                     }
                     else {
                         if (configuration.service_worker_relative_url) {
-                            this.publishEvent(eventNames.service_worker_not_supported_by_browser, {
+                            this.publishEvent(events_1.eventNames.service_worker_not_supported_by_browser, {
                                 message: 'service worker is not supported by this browser',
                             });
                         }
-                        const session = (0, initSession_1.initSession)(this.configurationName, configuration.redirect_uri, (_a = configuration.storage) !== null && _a !== void 0 ? _a : sessionStorage);
+                        const session = (0, initSession_1.initSession)(this.configurationName, (_a = configuration.storage) !== null && _a !== void 0 ? _a : sessionStorage);
                         const { tokens } = yield session.initAsync();
                         if (tokens) {
                             // @ts-ignore
                             this.tokens = (0, parseTokens_1.setTokens)(tokens, null, configuration.token_renew_mode);
+                            const getLoginParams = session.getLoginParams(this.configurationName);
                             // @ts-ignore
-                            this.timeoutId = autoRenewTokens(this, tokens.refreshToken, this.tokens.expiresAt);
+                            this.timeoutId = (0, renewTokens_1.autoRenewTokens)(this, tokens.refreshToken, this.tokens.expiresAt, getLoginParams.extras);
                             const sessionState = session.getSessionState();
                             // @ts-ignore
                             yield this.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, configuration.client_id, sessionState);
-                            this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
+                            this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_end, {
                                 success: true,
                                 message: 'tokens inside storage are valid',
                             });
                             return true;
                         }
                     }
-                    this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
+                    this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_end, {
                         success: false,
                         message: serviceWorker ? 'service worker sessions not retrieved' : 'session storage sessions not retrieved',
                     });
@@ -437,7 +260,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     if (serviceWorker) {
                         yield serviceWorker.clearAsync();
                     }
-                    this.publishEvent(eventNames.tryKeepExistingSessionAsync_error, 'tokens inside ServiceWorker are invalid');
+                    this.publishEvent(events_1.eventNames.tryKeepExistingSessionAsync_error, 'tokens inside ServiceWorker are invalid');
                     return false;
                 }
             });
@@ -448,159 +271,44 @@ 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;
+            const silentLoginAsync = (extras, state, scope) => {
+                return (0, silentLogin_1._silentLoginAsync)(this.configurationName, this.configuration, this.publishEvent.bind(this))(extras, state, scope);
+            };
+            this.checkSessionIFrame = yield (0, checkSession_1.startCheckSessionAsync)(oidcDatabase, this.configuration, this.checkSessionIFrame, 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;
             }
-            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();
+            if (silentLoginOnly) {
+                return (0, silentLogin_1.default)(window, this.configurationName, this.configuration, this.publishEvent.bind(this), this)(extras, scope);
+            }
+            this.loginPromise = (0, login_1.defaultLoginAsync)(window, this.configurationName, this.configuration, this.publishEvent.bind(this), this.initAsync.bind(this))(callbackPath, extras, isSilentSignin, scope);
             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) {
                 return this.loginCallbackPromise;
             }
             const loginCallbackLocalAsync = () => __awaiter(this, void 0, void 0, function* () {
-                const response = yield this._loginCallbackAsync(isSilenSignin);
+                const response = yield (0, login_1.loginCallbackAsync)(this)(isSilenSignin);
                 // @ts-ignore
                 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, this.configuration.redirect_uri);
+                const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(this.configuration.service_worker_relative_url, this.configurationName);
                 if (!serviceWorker) {
-                    const session = (0, initSession_1.initSession)(this.configurationName, this.configuration.redirect_uri, this.configuration.storage);
+                    const session = (0, initSession_1.initSession)(this.configurationName, this.configuration.storage);
                     session.setTokens(parsedTokens);
                 }
                 this.publishEvent(Oidc.eventNames.token_aquired, parsedTokens);
@@ -614,159 +322,23 @@ 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(eventNames.loginCallbackAsync_begin, {});
-                const configuration = this.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 = 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, configuration.redirect_uri);
-                let storage = null;
-                let nonceData = null;
-                if (serviceWorker) {
-                    serviceWorker.startKeepAliveServiceWorker();
-                    yield serviceWorker.initAsync(oidcServerConfiguration, 'loginCallbackAsync', configuration);
-                    const items = yield serviceWorker.loadItemsAsync();
-                    storage = new memoryStorageBackend_1.MemoryStorageBackend(serviceWorker.saveItemsAsync, items);
-                    const dummy = yield storage.getItem('dummy');
-                    if (!dummy) {
-                        throw new Error('Service Worker storage disapear');
-                    }
-                    yield storage.removeItem('dummy');
-                    yield serviceWorker.setSessionStateAsync(sessionState);
-                    nonceData = yield serviceWorker.getNonceAsync();
-                }
-                else {
-                    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();
-                }
-                return new Promise((resolve, reject) => {
-                    let queryStringUtil = new noHashQueryStringUtils_1.NoHashQueryStringUtils();
-                    if (redirectUri.includes('#')) {
-                        const splithash = window.location.href.split('#');
-                        if (splithash.length === 2 && splithash[1].includes('?')) {
-                            queryStringUtil = new noHashQueryStringUtils_1.HashQueryStringUtils();
-                        }
-                    }
-                    const authorizationHandler = new appauth_1.RedirectRequestHandler(storage, queryStringUtil, window.location, new appauth_1.DefaultCrypto());
-                    const notifier = new appauth_1.AuthorizationNotifier();
-                    authorizationHandler.setAuthorizationNotifier(notifier);
-                    notifier.setAuthorizationListener((request, response, error) => {
-                        if (error) {
-                            reject(error);
-                            return;
-                        }
-                        if (!response) {
-                            reject(new Error('no response'));
-                            return;
-                        }
-                        let extras = null;
-                        if (request && request.internal) {
-                            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;
-                                }
-                            }
-                        }
-                        const tokenRequest = new appauth_1.TokenRequest({
-                            client_id: clientId,
-                            redirect_uri: redirectUri,
-                            grant_type: appauth_1.GRANT_TYPE_AUTHORIZATION_CODE,
-                            code: response.code,
-                            refresh_token: undefined,
-                            extras,
-                        });
-                        let timeoutId = setTimeout(() => {
-                            reject(new Error('performTokenRequest timeout'));
-                            timeoutId = null;
-                        }, tokenRequestTimeout !== null && tokenRequestTimeout !== void 0 ? tokenRequestTimeout : 12000);
-                        try {
-                            const tokenHandler = new appauth_1.BaseTokenRequestHandler(new appauth_1.FetchRequestor());
-                            tokenHandler.performTokenRequest(oidcServerConfiguration, tokenRequest).then((tokenResponse) => __awaiter(this, void 0, void 0, function* () {
-                                if (timeoutId) {
-                                    clearTimeout(timeoutId);
-                                    this.timeoutId = null;
-                                    let loginParams = null;
-                                    let formattedTokens = null;
-                                    if (serviceWorker) {
-                                        const { tokens } = yield serviceWorker.initAsync(oidcServerConfiguration, 'syncTokensAsync', configuration);
-                                        loginParams = serviceWorker.getLoginParams(this.configurationName, redirectUri);
-                                        formattedTokens = tokens;
-                                    }
-                                    else {
-                                        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)) {
-                                        const exception = new Error('Tokens are not OpenID valid');
-                                        if (timeoutId) {
-                                            clearTimeout(timeoutId);
-                                            this.timeoutId = null;
-                                            this.publishEvent(eventNames.loginCallbackAsync_error, exception);
-                                            console.error(exception);
-                                            reject(exception);
-                                        }
-                                    }
-                                    this.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, clientId, sessionState, isSilentSignin).then(() => {
-                                        this.publishEvent(eventNames.loginCallbackAsync_end, {});
-                                        resolve({
-                                            tokens: formattedTokens,
-                                            state: request.state,
-                                            callbackPath: loginParams.callbackPath,
-                                        });
-                                    });
-                                }
-                            }));
-                        }
-                        catch (exception) {
-                            if (timeoutId) {
-                                clearTimeout(timeoutId);
-                                this.timeoutId = null;
-                                this.publishEvent(eventNames.loginCallbackAsync_error, exception);
-                                console.error(exception);
-                                reject(exception);
-                            }
-                        }
-                    });
-                    authorizationHandler.completeAuthorizationRequestIfPossible();
-                });
-            }
-            catch (exception) {
-                console.error(exception);
-                this.publishEvent(eventNames.loginCallbackAsync_error, exception);
-                throw exception;
-            }
-        });
-    }
     synchroniseTokensAsync(refreshToken, index = 0, forceRefresh = false, extras = null, updateTokens) {
         return __awaiter(this, void 0, void 0, function* () {
             while (!navigator.onLine && document.hidden) {
                 yield (0, initWorker_1.sleepAsync)(1000);
-                this.publishEvent(eventNames.refreshTokensAsync, { message: 'wait because navigator is offline and hidden' });
+                this.publishEvent(events_1.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(eventNames.refreshTokensAsync, { message: `wait because navigator is offline try ${numberTryOnline}` });
+                this.publishEvent(events_1.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(eventNames.refreshTokensAsync, { message: `wait because navigator is hidden try ${numberTryHidden}` });
+                this.publishEvent(events_1.eventNames.refreshTokensAsync, { message: `wait because navigator is hidden try ${numberTryHidden}` });
             }
             const isDocumentHidden = document.hidden;
             const nextIndex = isDocumentHidden ? index : index + 1;
@@ -774,18 +346,21 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 extras = {};
             }
             const configuration = this.configuration;
+            const silentLoginAsync = (extras, state, scope = null) => {
+                return (0, silentLogin_1._silentLoginAsync)(this.configurationName, this.configuration, this.publishEvent.bind(this))(extras, state, scope);
+            };
             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, configuration.redirect_uri);
+                    const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, this.configurationName);
                     if (serviceWorker) {
-                        loginParams = serviceWorker.getLoginParams(this.configurationName, configuration.redirect_uri);
+                        loginParams = serviceWorker.getLoginParams(this.configurationName);
                     }
                     else {
-                        const session = (0, initSession_1.initSession)(this.configurationName, configuration.redirect_uri, configuration.storage);
-                        loginParams = session.getLoginParams(this.configurationName, configuration.redirect_uri);
+                        const session = (0, initSession_1.initSession)(this.configurationName, configuration.storage);
+                        loginParams = session.getLoginParams(this.configurationName);
                     }
-                    const silent_token_response = yield this.silentLoginAsync(Object.assign(Object.assign(Object.assign({}, loginParams.extras), extras), { prompt: 'none' }), loginParams.state);
+                    const silent_token_response = yield silentLoginAsync(Object.assign(Object.assign(Object.assign({}, loginParams.extras), extras), { prompt: 'none' }), loginParams.state);
                     if (silent_token_response) {
                         updateTokens(silent_token_response.tokens);
                         this.publishEvent(Oidc.eventNames.token_renewed, {});
@@ -794,18 +369,18 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 }
                 catch (exceptionSilent) {
                     console.error(exceptionSilent);
-                    this.publishEvent(eventNames.refreshTokensAsync_silent_error, { message: 'exceptionSilent', exception: exceptionSilent.message });
+                    this.publishEvent(events_1.eventNames.refreshTokensAsync_silent_error, { message: 'exceptionSilent', exception: exceptionSilent.message });
                     if (exceptionSilent && exceptionSilent.message && exceptionSilent.message.startsWith('oidc')) {
                         updateTokens(null);
-                        this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token silent' });
+                        this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token silent' });
                         return { tokens: null, status: 'SESSION_LOST' };
                     }
                 }
-                this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token silent return' });
+                this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token silent return' });
                 return yield this.synchroniseTokensAsync(null, nextIndex, forceRefresh, extras, updateTokens);
             });
             if (index > 4) {
-                this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token' });
+                this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token' });
                 return { tokens: null, status: 'SESSION_LOST' };
             }
             try {
@@ -813,7 +388,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 switch (status) {
                     case 'SESSION_LOST':
                         updateTokens(null);
-                        this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token session lost' });
+                        this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token session lost' });
                         return { tokens: null, status: 'SESSION_LOST' };
                     case 'NOT_CONNECTED':
                         updateTokens(null);
@@ -827,13 +402,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(eventNames.logout_from_another_tab, { status: 'session syncTokensAsync' });
+                        this.publishEvent(events_1.eventNames.logout_from_another_tab, { status: 'session syncTokensAsync' });
                         return { tokens: null, status: 'LOGGED_OUT' };
                     case 'REQUIRE_SYNC_TOKENS':
-                        this.publishEvent(eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
+                        this.publishEvent(events_1.eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
                         return yield localsilentLoginAsync();
                     default: {
-                        this.publishEvent(eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
+                        this.publishEvent(events_1.eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
                         if (!refreshToken) {
                             return yield localsilentLoginAsync();
                         }
@@ -841,7 +416,12 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         const redirectUri = configuration.redirect_uri;
                         const authority = configuration.authority;
                         const tokenExtras = configuration.token_request_extras ? configuration.token_request_extras : {};
-                        const finalExtras = Object.assign(Object.assign({}, tokenExtras), extras);
+                        const finalExtras = Object.assign({}, tokenExtras);
+                        for (const [key, value] of Object.entries(extras)) {
+                            if (key.endsWith(':token_request')) {
+                                finalExtras[key.replace(':token_request', '')] = value;
+                            }
+                        }
                         const localFunctionAsync = () => __awaiter(this, void 0, void 0, function* () {
                             const details = {
                                 client_id: clientId,
@@ -855,16 +435,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(eventNames.refreshTokensAsync_error, { message: 'refresh token return not valid tokens' });
+                                    this.publishEvent(events_1.eventNames.refreshTokensAsync_error, { message: 'refresh token return not valid tokens' });
                                     return { tokens: null, status: 'SESSION_LOST' };
                                 }
                                 updateTokens(tokenResponse.data);
-                                this.publishEvent(eventNames.refreshTokensAsync_end, { success: tokenResponse.success });
+                                this.publishEvent(events_1.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(eventNames.refreshTokensAsync_silent_error, {
+                                this.publishEvent(events_1.eventNames.refreshTokensAsync_silent_error, {
                                     message: 'bad request',
                                     tokenResponse,
                                 });
@@ -878,7 +458,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             }
             catch (exception) {
                 console.error(exception);
-                this.publishEvent(eventNames.refreshTokensAsync_silent_error, { message: 'exception', exception: exception.message });
+                this.publishEvent(events_1.eventNames.refreshTokensAsync_silent_error, { message: 'exception', exception: exception.message });
                 return this.synchroniseTokensAsync(refreshToken, nextIndex, forceRefresh, extras, updateTokens);
             }
         });
@@ -894,7 +474,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, configuration.redirect_uri);
+            const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(configuration.service_worker_relative_url, configurationName);
             if (serviceWorker) {
                 const { status, tokens } = yield serviceWorker.initAsync(oidcServerConfiguration, 'syncTokensAsync', configuration);
                 if (status === 'LOGGED_OUT') {
@@ -915,7 +495,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, configuration.redirect_uri, (_a = configuration.storage) !== null && _a !== void 0 ? _a : sessionStorage);
+                const session = (0, initSession_1.initSession)(configurationName, (_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 };
@@ -953,7 +533,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         if (this.userInfoPromise !== null) {
             return this.userInfoPromise;
         }
-        this.userInfoPromise = userInfoAsync(this);
+        this.userInfoPromise = (0, user_1.userInfoAsync)(this);
         return this.userInfoPromise.then(result => {
             this.userInfoPromise = null;
             return result;
@@ -966,7 +546,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             }
             timer_1.default.clearTimeout(this.timeoutId);
             // @ts-ignore
-            yield renewTokensAndStartTimerAsync(this, this.tokens.refreshToken, true, extras);
+            yield (0, renewTokens_1.renewTokensAndStartTimerAsync)(this, this.tokens.refreshToken, true, extras);
         });
     }
     destroyAsync(status) {
@@ -976,9 +556,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, this.configuration.redirect_uri);
+            const serviceWorker = yield (0, initWorker_1.initWorkerAsync)(this.configuration.service_worker_relative_url, this.configurationName);
             if (!serviceWorker) {
-                const session = (0, initSession_1.initSession)(this.configurationName, this.configuration.redirect_uri, this.configuration.storage);
+                const session = (0, initSession_1.initSession)(this.configurationName, this.configuration.storage);
                 yield session.clearAsync(status);
             }
             else {
@@ -993,7 +573,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(eventNames.logout_from_same_tab, { message: sub });
+                this.publishEvent(events_1.eventNames.logout_from_same_tab, { message: sub });
                 yield this.destroyAsync('LOGGED_OUT');
             }
         });
@@ -1003,7 +583,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(eventNames.logout_from_another_tab, { message: 'SessionMonitor', sub });
+                this.publishEvent(events_1.eventNames.logout_from_another_tab, { message: 'SessionMonitor', sub });
             }
         });
     }
@@ -1083,6 +663,6 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
     }
 }
 exports.Oidc = Oidc;
-Oidc.eventNames = eventNames;
+Oidc.eventNames = events_1.eventNames;
 exports.default = Oidc;
 //# sourceMappingURL=oidc.js.map