@axa-fr/react-oidc 6.12.1 → 6.13.1

package/dist/vanilla/vanillaOidc.js.map

@@ -1 +1 @@
-{"version":3,"file":"vanillaOidc.js","sourceRoot":"","sources":["../../src/oidc/vanilla/vanillaOidc.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,iCAA2E;AAC3E,+CAAuE;AAMvE,MAAa,WAAW;IAEpB,YAAY,IAAU;QAClB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,eAAe,CAAC,IAAoB;QAChC,OAAO,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED,uBAAuB,CAAC,EAAS;QAC7B,IAAI,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED,YAAY,CAAC,SAAgB,EAAE,IAAQ;QACnC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,WAAW,CAAC,aAA+B,EAAE,IAAI,GAAG,SAAS;QAChE,OAAO,IAAI,WAAW,CAAC,WAAI,CAAC,WAAW,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC;IAClE,CAAC;IAED,MAAM,CAAC,GAAG,CAAC,IAAI,GAAG,SAAS;QACvB,OAAO,IAAI,WAAW,CAAC,WAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,CAAC;IAGD,2BAA2B;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,2BAA2B,EAAE,CAAC;IACpD,CAAC;IAED,UAAU,CAAC,eAAsB,SAAS,EAAE,SAAmB,IAAI,EAAE,cAAc,GAAG,KAAK,EAAE,QAAe,SAAS,EAAE,eAAe,GAAG,KAAK;QAC1I,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC;IAC/F,CAAC;IAED,WAAW,CAAC,oBAA+C,SAAS,EAAE,SAAoB,IAAI;QAC1F,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;IAC7D,CAAC;IAED,wBAAwB;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,wBAAwB,EAAE,CAAC;IACjD,CAAC;IAED,gBAAgB,CAAC,SAAmB,IAAI;QACpC,OAAO,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED,kBAAkB;QACd,OAAO,IAAI,CAAC,KAAK,CAAC,qCAAqC,EAAE,CAAC;IAC9D,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC7B,CAAC;IAED,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC;IACpC,CAAC;IAEK,kBAAkB,CAAC,MAAM,GAAG,GAAG,EAAE,UAAU,GAAG,EAAE;;YAClD,OAAO,IAAA,gCAAkB,EAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;QAC9D,CAAC;KAAA;IAEK,aAAa;;YACf,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QACtC,CAAC;KAAA;;AAjEL,kCAkEC;AAxCU,sBAAU,GAAG,WAAI,CAAC,UAAU,CAAC"}
+{"version":3,"file":"vanillaOidc.js","sourceRoot":"","sources":["../../src/oidc/vanilla/vanillaOidc.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,iCAA6C;AAC7C,+CAAuE;AAOvE,MAAa,WAAW;IAEpB,YAAY,IAAU;QAClB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,eAAe,CAAC,IAAoB;QAChC,OAAO,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED,uBAAuB,CAAC,EAAS;QAC7B,IAAI,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED,YAAY,CAAC,SAAgB,EAAE,IAAQ;QACnC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,WAAW,CAAC,aAA+B,EAAE,IAAI,GAAG,SAAS;QAChE,OAAO,IAAI,WAAW,CAAC,WAAI,CAAC,WAAW,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC;IAClE,CAAC;IAED,MAAM,CAAC,GAAG,CAAC,IAAI,GAAG,SAAS;QACvB,OAAO,IAAI,WAAW,CAAC,WAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,CAAC;IAGD,2BAA2B;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,2BAA2B,EAAE,CAAC;IACpD,CAAC;IAED,UAAU,CAAC,eAAsB,SAAS,EAAE,SAAmB,IAAI,EAAE,cAAc,GAAG,KAAK,EAAE,QAAe,SAAS,EAAE,eAAe,GAAG,KAAK;QAC1I,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC;IAC/F,CAAC;IAED,WAAW,CAAC,oBAA+C,SAAS,EAAE,SAAoB,IAAI;QAC1F,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;IAC7D,CAAC;IAED,wBAAwB;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,wBAAwB,EAAE,CAAC;IACjD,CAAC;IAED,gBAAgB,CAAC,SAAmB,IAAI;QACpC,OAAO,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED,kBAAkB;QACd,OAAO,IAAI,CAAC,KAAK,CAAC,qCAAqC,EAAE,CAAC;IAC9D,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC7B,CAAC;IAED,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC;IACpC,CAAC;IAEK,kBAAkB,CAAC,MAAM,GAAG,GAAG,EAAE,UAAU,GAAG,EAAE;;YAClD,OAAO,IAAA,gCAAkB,EAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;QAC9D,CAAC;KAAA;IAEK,aAAa;;YACf,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QACtC,CAAC;KAAA;;AAjEL,kCAkEC;AAxCU,sBAAU,GAAG,WAAI,CAAC,UAAU,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axa-fr/react-oidc",
-  "version": "6.12.1",
+  "version": "6.13.1",
   "private": false,
   "main": "dist/index.js",
   "jsnext:main": "dist/index.js",

package/src/oidc/OidcProvider.tsx

@@ -5,7 +5,7 @@ import { Authenticating, CallBackSuccess, Loading, SessionLost } from './core/de
 import ServiceWorkerNotSupported from './core/default-component/ServiceWorkerNotSupported.component';
 import OidcRoutes from './core/routes/OidcRoutes';
 import { CustomHistory } from './core/routes/withRouter';
-import { OidcConfiguration } from './vanilla/oidc';
+import { OidcConfiguration } from './vanilla/types';
 import { VanillaOidc } from './vanilla/vanillaOidc';
 
 export type oidcContext = {

package/src/oidc/OidcSecure.tsx

@@ -1,6 +1,6 @@
 import { FC, PropsWithChildren, useEffect } from 'react';
 
-import { StringMap } from './vanilla/oidc';
+import { StringMap } from './vanilla/types';
 import { VanillaOidc } from './vanilla/vanillaOidc';
 
 export type OidcSecureProps = {

package/src/oidc/ReactOidc.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useState } from 'react';
 
-import { StringMap } from './vanilla/oidc';
+import { StringMap } from './vanilla/types';
 import { VanillaOidc } from './vanilla/vanillaOidc';
 
 const defaultConfigurationName = 'default';

package/src/oidc/index.ts

@@ -3,5 +3,5 @@ export { OidcProvider } from './OidcProvider';
 export { OidcSecure, withOidcSecure } from './OidcSecure';
 export { useOidc, useOidcAccessToken, useOidcIdToken } from './ReactOidc';
 export { OidcUserStatus, useOidcUser } from './User';
-export type { OidcConfiguration } from './vanilla/oidc';
 export { TokenRenewMode } from './vanilla/parseTokens';
+export type { AuthorityConfiguration, OidcConfiguration, StringMap } from './vanilla/types';

package/src/oidc/vanilla/checkSession.ts

@@ -0,0 +1,55 @@
+import { CheckSessionIFrame } from './checkSessionIFrame';
+import { Tokens } from './parseTokens';
+import { OidcConfiguration } from './types';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export const startCheckSessionAsync = (oidcDatabase:any, configuration :OidcConfiguration, checkSessionIFrame: CheckSessionIFrame, silentLoginAsync:Function, getCurrentTokens: () => Tokens) => (checkSessionIFrameUri, clientId, sessionState, isSilentSignin = false) => {
+    return new Promise<CheckSessionIFrame>((resolve, reject): void => {
+        if (configuration.silent_login_uri && configuration.silent_redirect_uri && configuration.monitor_session && checkSessionIFrameUri && sessionState && !isSilentSignin) {
+            const checkSessionCallback = () => {
+                checkSessionIFrame.stop();
+                const tokens = getCurrentTokens();
+                if (tokens === null) {
+                    return;
+                }
+                const idToken = tokens.idToken;
+                const idTokenPayload = tokens.idTokenPayload;
+                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;
+                        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(async (e) => {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    for (const [key, oidc] of Object.entries(oidcDatabase)) {
+                        // @ts-ignore
+                        await oidc.logoutOtherTabAsync(this.configuration.client_id, idTokenPayload.sub);
+                    }
+                });
+            };
+
+            checkSessionIFrame = new CheckSessionIFrame(checkSessionCallback, clientId, checkSessionIFrameUri);
+            checkSessionIFrame.load().then(() => {
+                checkSessionIFrame.start(sessionState);
+                resolve(checkSessionIFrame);
+            }).catch((e) => {
+                reject(e);
+            });
+        } else {
+            resolve(null);
+        }
+    });
+};

package/src/oidc/vanilla/events.ts

@@ -0,0 +1,29 @@
+
+export 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',
+};

package/src/oidc/vanilla/index.ts

@@ -1,2 +1,2 @@
-export { OidcConfiguration } from './oidc';
+export { AuthorityConfiguration, OidcConfiguration, StringMap } from './types';
 export { VanillaOidc } from './vanillaOidc';

package/src/oidc/vanilla/initSession.ts

@@ -1,68 +1,62 @@
-export const initSession = (configurationName, redirectUri, storage = sessionStorage) => {
+export const initSession = (configurationName, storage = sessionStorage) => {
     const saveItemsAsync = (items) => {
-        storage[`oidc_items.${configurationName}:${redirectUri}`] = JSON.stringify(items);
+        storage[`oidc.items.${configurationName}`] = JSON.stringify(items);
         return Promise.resolve();
     };
 
     const loadItemsAsync = () => {
-        return Promise.resolve(JSON.parse(storage[`oidc_items.${configurationName}:${redirectUri}`]));
+        return Promise.resolve(JSON.parse(storage[`oidc.items.${configurationName}`]));
     };
 
     const clearAsync = (status) => {
-        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({ tokens: null, status });
+        storage[`oidc.${configurationName}`] = JSON.stringify({ tokens: null, status });
         return Promise.resolve();
     };
 
     const initAsync = async () => {
-        if (!storage[`oidc.${configurationName}:${redirectUri}`]) {
-            storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({ tokens: null, status: null });
+        if (!storage[`oidc.${configurationName}`]) {
+            storage[`oidc.${configurationName}`] = JSON.stringify({ tokens: null, status: null });
             return { tokens: null, status: null };
         }
-        const data = JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]);
+        const data = JSON.parse(storage[`oidc.${configurationName}`]);
         return Promise.resolve({ tokens: data.tokens, status: data.status });
     };
 
     const setTokens = (tokens) => {
-        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({ tokens });
+        storage[`oidc.${configurationName}`] = JSON.stringify({ tokens });
     };
 
     const setSessionState = (sessionState) => {
-        storage[`oidc.session_state.${configurationName}:${redirectUri}`] = sessionState;
+        storage[`oidc.session_state.${configurationName}`] = sessionState;
     };
 
     const getSessionState = () => {
-        return storage[`oidc.session_state.${configurationName}:${redirectUri}`];
+        return storage[`oidc.session_state.${configurationName}`];
     };
 
     const setNonceAsync = (nonce) => {
-        localStorage[`oidc.nonce.${configurationName}:${redirectUri}`] = nonce.nonce;
+        localStorage[`oidc.nonce.${configurationName}`] = nonce.nonce;
     };
 
     const getNonceAsync = async () => {
         // @ts-ignore
-        return { nonce: localStorage[`oidc.nonce.${configurationName}:${redirectUri}`] };
+        return { nonce: localStorage[`oidc.nonce.${configurationName}`] };
     };
 
     const getTokens = () => {
-        if (!storage[`oidc.${configurationName}:${redirectUri}`]) {
+        if (!storage[`oidc.${configurationName}`]) {
             return null;
         }
-        return JSON.stringify({ tokens: JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]).tokens });
+        return JSON.stringify({ tokens: JSON.parse(storage[`oidc.${configurationName}`]).tokens });
     };
 
-    const getLoginSessionKey = (configurationName:string, redirectUri:string) => {
-        return `oidc_login.${configurationName}:${redirectUri}`;
-    };
-
-    const setLoginParams = (configurationName:string, redirectUri:string, data) => {
-        const sessionKey = getLoginSessionKey(configurationName, redirectUri);
+    let getLoginParamsCache = null;
+    const setLoginParams = (configurationName:string, data) => {
         getLoginParamsCache = data;
-        storage[sessionKey] = JSON.stringify(data);
+        storage[`oidc.login.${configurationName}`] = JSON.stringify(data);
     };
-
-    let getLoginParamsCache = null;
-    const getLoginParams = (configurationName, redirectUri) => {
-        const dataString = storage[getLoginSessionKey(configurationName, redirectUri)];
+    const getLoginParams = (configurationName) => {
+        const dataString = storage[`oidc.login.${configurationName}`];
         if (!getLoginParamsCache) {
             getLoginParamsCache = JSON.parse(dataString);
         }

package/src/oidc/vanilla/initWorker.ts

@@ -1,7 +1,7 @@
 import { initSession } from './initSession';
-import { OidcConfiguration } from './oidc';
 import { parseOriginalTokens } from './parseTokens';
 import timer from './timer';
+import { OidcConfiguration } from './types';
 
 export const getOperatingSystem = () => {
     const nVer = navigator.appVersion;
@@ -140,7 +140,7 @@ const sendMessageAsync = (registration) => (data) => {
     });
 };
 
-export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName, redirectUri) => {
+export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName) => {
     if (typeof window === 'undefined' || typeof navigator === 'undefined' || !navigator.serviceWorker || !serviceWorkerRelativeUrl) {
         return null;
     }
@@ -192,7 +192,7 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
     const saveItemsAsync = (items) => {
         // iOS kill Service Worker when domain we leave domain
         if (operatingSystem.os === 'iOS') {
-            const session = initSession(configurationName, redirectUri);
+            const session = initSession(configurationName);
             return session.saveItemsAsync(items);
         }
         return sendMessageAsync(registration)({ type: 'saveItems', data: items, configurationName });
@@ -200,7 +200,7 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
     const loadItemsAsync = () => {
         // iOS kill Service Worker when domain we leave domain
         if (operatingSystem.os === 'iOS') {
-            const session = initSession(configurationName, redirectUri);
+            const session = initSession(configurationName);
             return session.loadItemsAsync();
         }
         return sendMessageAsync(registration)({ type: 'loadItems', data: null, configurationName });
@@ -208,7 +208,7 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
     const clearAsync = async (status) => {
         // iOS kill Service Worker when domain we leave domain
         if (operatingSystem.os === 'iOS') {
-            const session = initSession(configurationName, redirectUri);
+            const session = initSession(configurationName);
             await session.clearAsync(status);
         }
         return sendMessageAsync(registration)({ type: 'clear', data: { status }, configurationName });
@@ -243,7 +243,7 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
     const setNonceAsync = (nonce) => {
         // iOS kill Service Worker when domain we leave domain
         if (operatingSystem.os === 'iOS') {
-            const session = initSession(configurationName, redirectUri);
+            const session = initSession(configurationName);
             return session.setNonceAsync(nonce);
         }
         return sendMessageAsync(registration)({ type: 'setNonce', data: { nonce }, configurationName });
@@ -253,7 +253,7 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
     const getNonceAsync = async () => {
         // iOS kill Service Worker when domain we leave domain
         if (operatingSystem.os === 'iOS') {
-            const session = initSession(configurationName, redirectUri);
+            const session = initSession(configurationName);
             return session.getNonceAsync();
         }
         // @ts-ignore
@@ -261,19 +261,13 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
         return { nonce: keyNonce };
     };
 
-    const getLoginSessionKey = (configurationName:string, redirectUri:string) => {
-        return `oidc_login.${configurationName}:${redirectUri}`;
-    };
-
-    const setLoginParams = (configurationName:string, redirectUri:string, data) => {
-        const sessionKey = getLoginSessionKey(configurationName, redirectUri);
+    let getLoginParamsCache = null;
+    const setLoginParams = (configurationName:string, data) => {
         getLoginParamsCache = data;
-        sessionStorage[sessionKey] = JSON.stringify(data);
+        localStorage[`oidc.login.${configurationName}`] = JSON.stringify(data);
     };
-
-    let getLoginParamsCache = null;
-    const getLoginParams = (configurationName, redirectUri) => {
-        const dataString = sessionStorage[getLoginSessionKey(configurationName, redirectUri)];
+    const getLoginParams = (configurationName) => {
+        const dataString = localStorage[`oidc.login.${configurationName}`];
         if (!getLoginParamsCache) {
             getLoginParamsCache = JSON.parse(dataString);
         }

package/src/oidc/vanilla/login.ts

@@ -0,0 +1,242 @@
+import {
+    AuthorizationNotifier,
+    AuthorizationRequest, BaseTokenRequestHandler,
+    DefaultCrypto, FetchRequestor, GRANT_TYPE_AUTHORIZATION_CODE,
+    RedirectRequestHandler,
+    TokenRequest,
+} from '@openid/appauth';
+
+import { eventNames } from './events';
+import { initSession } from './initSession';
+import { initWorkerAsync } from './initWorker';
+import { MemoryStorageBackend } from './memoryStorageBackend';
+import { HashQueryStringUtils, NoHashQueryStringUtils } from './noHashQueryStringUtils';
+import { isTokensOidcValid, setTokens } from './parseTokens';
+import { getParseQueryStringFromLocation } from './route-utils';
+import { OidcConfiguration, StringMap } from './types';
+
+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;
+};
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export const defaultLoginAsync = (window, configurationName, configuration:OidcConfiguration, publishEvent :(string, any)=>void, initAsync:Function) => (callbackPath:string = undefined, extras:StringMap = null, isSilentSignin = false, scope:string = undefined) => {
+    const originExtras = extras;
+    extras = { ...extras };
+    const loginLocalAsync = async () => {
+        const location = window.location;
+        const url = callbackPath || location.pathname + (location.search || '') + (location.hash || '');
+        let state;
+        if (extras && 'state' in extras) {
+            state = extras.state;
+            delete extras.state;
+        }
+
+        publishEvent(eventNames.loginAsync_begin, {});
+        if (extras) {
+            for (const key of Object.keys(extras)) {
+                if (key.endsWith(':token_request')) {
+                    delete extras[key];
+                }
+            }
+        }
+        try {
+            const redirectUri = isSilentSignin ? configuration.silent_redirect_uri : configuration.redirect_uri;
+            if (!scope) {
+                scope = configuration.scope;
+            }
+
+            const extraFinal = !configuration.extras ? extras : { ...configuration.extras, ...extras };
+            if (!extraFinal.nonce) {
+                extraFinal.nonce = randomString(12);
+            }
+            const nonce = { nonce: extraFinal.nonce };
+            const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, configurationName);
+            const oidcServerConfiguration = await initAsync(configuration.authority, configuration.authority_configuration);
+            let storage;
+            if (serviceWorker) {
+                serviceWorker.setLoginParams(configurationName, { callbackPath: url, extras: originExtras, state });
+                serviceWorker.startKeepAliveServiceWorker();
+                await serviceWorker.initAsync(oidcServerConfiguration, 'loginAsync', configuration);
+                await serviceWorker.setNonceAsync(nonce);
+                storage = new MemoryStorageBackend(serviceWorker.saveItemsAsync, {});
+                await storage.setItem('dummy', {});
+            } else {
+                let session = initSession(configurationName, configuration.storage ?? sessionStorage);
+                session.setLoginParams(configurationName, { callbackPath: url, extras: originExtras, state });
+                session = initSession(configurationName);
+                await session.setNonceAsync(nonce);
+                storage = new MemoryStorageBackend(session.saveItemsAsync, {});
+            }
+
+            // @ts-ignore
+            const queryStringUtil = redirectUri.includes('#') ? new HashQueryStringUtils() : new NoHashQueryStringUtils();
+            const authorizationHandler = new RedirectRequestHandler(storage, queryStringUtil, window.location, new DefaultCrypto());
+            const authRequest = new AuthorizationRequest({
+                client_id: configuration.client_id,
+                redirect_uri: redirectUri,
+                scope,
+                response_type: AuthorizationRequest.RESPONSE_TYPE_CODE,
+                state,
+                extras: extraFinal,
+            });
+            authorizationHandler.performAuthorizationRequest(oidcServerConfiguration, authRequest);
+        } catch (exception) {
+            publishEvent(eventNames.loginAsync_error, exception);
+            throw exception;
+        }
+    };
+    return loginLocalAsync();
+};
+
+export const loginCallbackAsync = (oidc) => async (isSilentSignin = false) => {
+    try {
+        oidc.publishEvent(eventNames.loginCallbackAsync_begin, {});
+        const configuration = oidc.configuration;
+        const clientId = configuration.client_id;
+        const redirectUri = isSilentSignin ? configuration.silent_redirect_uri : configuration.redirect_uri;
+        const authority = configuration.authority;
+        const tokenRequestTimeout = configuration.token_request_timeout;
+        const oidcServerConfiguration = await oidc.initAsync(authority, configuration.authority_configuration);
+        const queryParams = getParseQueryStringFromLocation(window.location.href);
+        const sessionState = queryParams.session_state;
+        const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, oidc.configurationName);
+        let storage = null;
+        let nonceData = null;
+        let getLoginParams = null;
+        if (serviceWorker) {
+            serviceWorker.startKeepAliveServiceWorker();
+            await serviceWorker.initAsync(oidcServerConfiguration, 'loginCallbackAsync', configuration);
+            const items = await serviceWorker.loadItemsAsync();
+            storage = new MemoryStorageBackend(serviceWorker.saveItemsAsync, items);
+            const dummy = await storage.getItem('dummy');
+            if (!dummy) {
+                throw new Error('Service Worker storage disapear');
+            }
+            await storage.removeItem('dummy');
+            await serviceWorker.setSessionStateAsync(sessionState);
+            nonceData = await serviceWorker.getNonceAsync();
+            getLoginParams = serviceWorker.getLoginParams(oidc.configurationName);
+        } else {
+            const session = initSession(oidc.configurationName);
+            session.setSessionState(sessionState);
+            const items = await session.loadItemsAsync();
+            storage = new MemoryStorageBackend(session.saveItemsAsync, items);
+            nonceData = await session.getNonceAsync();
+            getLoginParams = session.getLoginParams(oidc.configurationName);
+        }
+
+        return new Promise((resolve, reject) => {
+            let queryStringUtil = new NoHashQueryStringUtils();
+            if (redirectUri.includes('#')) {
+                const splithash = window.location.href.split('#');
+                if (splithash.length === 2 && splithash[1].includes('?')) {
+                    queryStringUtil = new HashQueryStringUtils();
+                }
+            }
+            const authorizationHandler = new RedirectRequestHandler(storage, queryStringUtil, window.location, new DefaultCrypto());
+            const notifier = new AuthorizationNotifier();
+            authorizationHandler.setAuthorizationNotifier(notifier);
+
+            notifier.setAuthorizationListener((request, response, error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                if (!response) {
+                    reject(new Error('no response'));
+                    return;
+                }
+
+                const extras = {};
+                if (request && request.internal) {
+                    // @ts-ignore
+                    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 TokenRequest({
+                    client_id: clientId,
+                    redirect_uri: redirectUri, // @ts-ignore
+                    grant_type: GRANT_TYPE_AUTHORIZATION_CODE,
+                    code: response.code,
+                    refresh_token: undefined,
+                    extras,
+                });
+
+                let timeoutId = setTimeout(() => {
+                    reject(new Error('performTokenRequest timeout'));
+                    timeoutId = null;
+                }, tokenRequestTimeout ?? 12000);
+                try {
+                    const tokenHandler = new BaseTokenRequestHandler(new FetchRequestor());
+                    tokenHandler.performTokenRequest(oidcServerConfiguration, tokenRequest).then(async (tokenResponse) => {
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
+                            oidc.timeoutId = null;
+                            let loginParams = null;
+                            let formattedTokens = null;
+                            if (serviceWorker) {
+                                const { tokens } = await serviceWorker.initAsync(oidcServerConfiguration, 'syncTokensAsync', configuration);
+                                loginParams = serviceWorker.getLoginParams(oidc.configurationName);
+                                formattedTokens = tokens;
+                            } else {
+                                const session = initSession(oidc.configurationName, configuration.storage);
+                                loginParams = session.getLoginParams(oidc.configurationName);
+                                formattedTokens = setTokens(tokenResponse, null, configuration.token_renew_mode);
+                            }
+                            if (!isTokensOidcValid(formattedTokens, nonceData.nonce, oidcServerConfiguration)) {
+                                const exception = new Error('Tokens are not OpenID valid');
+                                if (timeoutId) {
+                                    clearTimeout(timeoutId);
+                                    oidc.timeoutId = null;
+                                    oidc.publishEvent(eventNames.loginCallbackAsync_error, exception);
+                                    console.error(exception);
+                                    reject(exception);
+                                }
+                            }
+
+                            oidc.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, clientId, sessionState, isSilentSignin).then(() => {
+                                oidc.publishEvent(eventNames.loginCallbackAsync_end, {});
+                                resolve({
+                                    tokens: formattedTokens,
+                                    state: request.state,
+                                    callbackPath: loginParams.callbackPath,
+                                });
+                            });
+                        }
+                    });
+                } catch (exception) {
+                    if (timeoutId) {
+                        clearTimeout(timeoutId);
+                        oidc.timeoutId = null;
+                        oidc.publishEvent(eventNames.loginCallbackAsync_error, exception);
+                        console.error(exception);
+                        reject(exception);
+                    }
+                }
+            });
+            authorizationHandler.completeAuthorizationRequestIfPossible();
+        });
+    } catch (exception) {
+        console.error(exception);
+        oidc.publishEvent(eventNames.loginCallbackAsync_error, exception);
+        throw exception;
+    }
+};