@axa-fr/react-oidc 6.13.3 → 6.14.0

package/src/oidc/vanilla/login.ts

@@ -1,29 +1,12 @@
-import {
-    AuthorizationNotifier,
-    AuthorizationRequest, BaseTokenRequestHandler,
-    DefaultCrypto, FetchRequestor, GRANT_TYPE_AUTHORIZATION_CODE,
-    RedirectRequestHandler,
-    TokenRequest,
-} from '@openid/appauth';
-
+import { generateRandom } from './crypto';
 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 { isTokensOidcValid } from './parseTokens';
+import { performAuthorizationRequestAsync, performFirstTokenRequestAsync } from './requests';
 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;
@@ -31,10 +14,9 @@ export const defaultLoginAsync = (window, configurationName, configuration:OidcC
     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;
+
+        if (!('state' in extras)) {
+            extras.state = generateRandom(16);
         }
 
         publishEvent(eventNames.loginAsync_begin, {});
@@ -53,38 +35,34 @@ export const defaultLoginAsync = (window, configurationName, configuration:OidcC
 
             const extraFinal = !configuration.extras ? extras : { ...configuration.extras, ...extras };
             if (!extraFinal.nonce) {
-                extraFinal.nonce = randomString(12);
+                extraFinal.nonce = generateRandom(12);
             }
             const nonce = { nonce: extraFinal.nonce };
             const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, configurationName);
             const oidcServerConfiguration = await initAsync(configuration.authority, configuration.authority_configuration);
             let storage;
             if (serviceWorker) {
-                serviceWorker.setLoginParams(configurationName, { callbackPath: url, extras: originExtras, state });
+                serviceWorker.setLoginParams(configurationName, { callbackPath: url, extras: originExtras });
                 serviceWorker.startKeepAliveServiceWorker();
                 await serviceWorker.initAsync(oidcServerConfiguration, 'loginAsync', configuration);
                 await serviceWorker.setNonceAsync(nonce);
-                storage = new MemoryStorageBackend(serviceWorker.saveItemsAsync, {});
-                await storage.setItem('dummy', {});
+                storage = serviceWorker;
             } else {
                 const session = initSession(configurationName, configuration.storage ?? sessionStorage);
-                session.setLoginParams(configurationName, { callbackPath: url, extras: originExtras, state });
+                session.setLoginParams(configurationName, { callbackPath: url, extras: originExtras });
                 await session.setNonceAsync(nonce);
-                storage = new MemoryStorageBackend(session.saveItemsAsync, {});
+                storage = session;
             }
 
             // @ts-ignore
-            const queryStringUtil = redirectUri.includes('#') ? new HashQueryStringUtils() : new NoHashQueryStringUtils();
-            const authorizationHandler = new RedirectRequestHandler(storage, queryStringUtil, window.location, new DefaultCrypto());
-            const authRequest = new AuthorizationRequest({
+            const extraInternal = {
                 client_id: configuration.client_id,
                 redirect_uri: redirectUri,
                 scope,
-                response_type: AuthorizationRequest.RESPONSE_TYPE_CODE,
-                state,
-                extras: extraFinal,
-            });
-            authorizationHandler.performAuthorizationRequest(oidcServerConfiguration, authRequest);
+                response_type: 'code',
+                ...extraFinal,
+            };
+            await performAuthorizationRequestAsync(storage)(oidcServerConfiguration.authorizationEndpoint, extraInternal);
         } catch (exception) {
             publishEvent(eventNames.loginAsync_error, exception);
             throw exception;
@@ -105,134 +83,84 @@ export const loginCallbackAsync = (oidc) => async (isSilentSignin = false) => {
         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;
+        let storage;
+        let nonceData;
+        let getLoginParams;
+        let state;
         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);
+            state = await serviceWorker.getStateAsync();
+            storage = serviceWorker;
         } else {
             const session = initSession(oidc.configurationName, configuration.storage ?? sessionStorage);
-            session.setSessionState(sessionState);
-            const items = await session.loadItemsAsync();
-            storage = new MemoryStorageBackend(session.saveItemsAsync, items);
+            await session.setSessionStateAsync(sessionState);
             nonceData = await session.getNonceAsync();
             getLoginParams = session.getLoginParams(oidc.configurationName);
+            state = await session.getStateAsync();
+            storage = session;
         }
 
-        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);
+        const params = getParseQueryStringFromLocation(window.location.toString());
 
-            notifier.setAuthorizationListener((request, response, error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                if (!response) {
-                    reject(new Error('no response'));
-                    return;
-                }
+        if (params.iss && params.iss !== oidcServerConfiguration.issuer) {
+            throw new Error('issuer not valid');
+        }
+        if (params.state && params.state !== state) {
+            throw new Error('state not valid');
+        }
+
+        const data = {
+            code: params.code,
+            grant_type: 'authorization_code',
+            client_id: configuration.client_id,
+            redirect_uri: redirectUri,
+        };
 
-                const extras = {};
-                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 extras = {};
+        // @ts-ignore
+        if (configuration.token_request_extras) {
+            for (const [key, value] of Object.entries(configuration.token_request_extras)) {
+                extras[key] = value;
+            }
+        }
+        if (getLoginParams && getLoginParams.extras) {
+            for (const [key, value] of Object.entries(getLoginParams.extras)) {
+                if (key.endsWith(':token_request')) {
+                    extras[key.replace(':token_request', '')] = value;
                 }
+            }
+        }
 
-                const tokenRequest = new TokenRequest({
-                    client_id: clientId,
-                    redirect_uri: redirectUri, // @ts-ignore
-                    grant_type: GRANT_TYPE_AUTHORIZATION_CODE,
-                    code: response.code,
-                    refresh_token: undefined,
-                    extras,
-                });
+        const tokenResponse = await performFirstTokenRequestAsync(storage)(oidcServerConfiguration.tokenEndpoint, { ...data, ...extras }, oidc.configuration.token_renew_mode, tokenRequestTimeout);
 
-                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);
-                                }
-                            }
+        let loginParams = null;
+        const formattedTokens = tokenResponse.data.tokens;
+        if (serviceWorker) {
+            await serviceWorker.initAsync(redirectUri, 'syncTokensAsync', configuration);
+            loginParams = serviceWorker.getLoginParams(oidc.configurationName);
+        } else {
+            const session = initSession(oidc.configurationName, configuration.storage);
+            loginParams = session.getLoginParams(oidc.configurationName);
+        }
+        // @ts-ignore
+        if (tokenResponse.data.state !== extras.state) {
+            throw new Error('state is not valid');
+        }
+        if (!isTokensOidcValid(formattedTokens, nonceData.nonce, oidcServerConfiguration)) {
+            throw new Error('Tokens are not OpenID valid');
+        }
 
-                            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();
-        });
+        await oidc.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, clientId, sessionState, isSilentSignin);
+        oidc.publishEvent(eventNames.loginCallbackAsync_end, {});
+        return {
+            tokens: formattedTokens,
+            state: 'request.state',
+            callbackPath: loginParams.callbackPath,
+        };
     } catch (exception) {
         console.error(exception);
         oidc.publishEvent(eventNames.loginCallbackAsync_error, exception);

package/src/oidc/vanilla/oidc.ts

@@ -1,8 +1,3 @@
-import {
-    AuthorizationServiceConfiguration,
-    GRANT_TYPE_REFRESH_TOKEN,
-} from '@openid/appauth';
-import { AuthorizationServiceConfigurationJson } from '@openid/appauth/src/authorization_service_configuration';
 
 import { startCheckSessionAsync as defaultStartCheckSessionAsync } from './checkSession';
 import { CheckSessionIFrame } from './checkSessionIFrame';
@@ -24,23 +19,28 @@ import timer from './timer';
 import { AuthorityConfiguration, OidcConfiguration, StringMap } from './types';
 import { userInfoAsync } from './user';
 
-export interface OidcAuthorizationServiceConfigurationJson extends AuthorizationServiceConfigurationJson{
+export interface OidcAuthorizationServiceConfigurationJson {
     check_session_iframe?: string;
     issuer:string;
 }
 
-export class OidcAuthorizationServiceConfiguration extends AuthorizationServiceConfiguration {
-    private check_session_iframe: string;
+export class OidcAuthorizationServiceConfiguration {
+    private checkSessionIframe: string;
     private issuer: string;
+    private authorizationEndpoint: string;
+    private tokenEndpoint: string;
+    private revocationEndpoint: string;
+    private userInfoEndpoint: string;
+    private endSessionEndpoint: string;
 
     constructor(request: any) {
-        super(request);
         this.authorizationEndpoint = request.authorization_endpoint;
         this.tokenEndpoint = request.token_endpoint;
         this.revocationEndpoint = request.revocation_endpoint;
         this.userInfoEndpoint = request.userinfo_endpoint;
-        this.check_session_iframe = request.check_session_iframe;
+        this.checkSessionIframe = request.check_session_iframe;
         this.issuer = request.issuer;
+        this.endSessionEndpoint = request.end_session_endpoint;
     }
 }
 
@@ -246,7 +246,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         const getLoginParams = session.getLoginParams(this.configurationName);
                         // @ts-ignore
                         this.timeoutId = autoRenewTokens(this, tokens.refreshToken, this.tokens.expiresAt, getLoginParams.extras);
-                        const sessionState = session.getSessionState();
+                        const sessionState = await session.getSessionStateAsync();
                         // @ts-ignore
                         await this.startCheckSessionAsync(oidcServerConfiguration.check_session_iframe, configuration.client_id, sessionState);
                         this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
@@ -440,7 +440,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         const details = {
                             client_id: clientId,
                             redirect_uri: redirectUri,
-                            grant_type: GRANT_TYPE_REFRESH_TOKEN,
+                            grant_type: 'refresh_token',
                             refresh_token: tokens.refreshToken,
                         };
                         const oidcServerConfiguration = await this.initAsync(authority, configuration.authority_configuration);
@@ -548,13 +548,22 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
          });
      }
 
+    renewTokensPromise:Promise<any> = null;
+
      async renewTokensAsync (extras:StringMap = null) {
+         if (this.renewTokensPromise !== null) {
+             return this.renewTokensPromise;
+         }
          if (!this.timeoutId) {
              return;
          }
          timer.clearTimeout(this.timeoutId);
          // @ts-ignore
-         await renewTokensAndStartTimerAsync(this, this.tokens.refreshToken, true, extras);
+         this.renewTokensPromise = renewTokensAndStartTimerAsync(this, this.tokens.refreshToken, true, extras);
+         return this.renewTokensPromise.then(result => {
+             this.renewTokensPromise = null;
+             return result;
+         });
      }
 
      async destroyAsync(status) {

package/src/oidc/vanilla/requests.spec.ts

@@ -0,0 +1,4 @@
+
+test('performAuthorizationRequestAsync', async () => {
+    expect(true).toBe(true);
+});

package/src/oidc/vanilla/requests.ts

@@ -1,6 +1,8 @@
 import { getFromCache, setCache } from './cache';
+import { deriveChallengeAsync, generateRandom } from './crypto';
 import { OidcAuthorizationServiceConfiguration } from './oidc';
 import { parseOriginalTokens } from './parseTokens';
+import { StringMap } from './types';
 
 const oneHourSecond = 60 * 60;
 export const fetchFromIssuer = async (openIdIssuerUrl: string, timeCacheSecond = oneHourSecond, storage = window.sessionStorage):
@@ -112,3 +114,56 @@ export const performTokenRequestAsync = async (url, details, extras, oldTokens,
         data: parseOriginalTokens(tokens, oldTokens, tokenRenewMode),
     };
 };
+
+export const performAuthorizationRequestAsync = (storage: any) => async (url, extras: StringMap) => {
+    extras = extras ? { ...extras } : {};
+    const codeVerifier = generateRandom(128);
+    const codeChallenge = await deriveChallengeAsync(codeVerifier);
+    await storage.setCodeVerifierAsync(codeVerifier);
+    await storage.setStateAsync(extras.state);
+    extras.code_challenge = codeChallenge;
+    extras.code_challenge_method = 'S256';
+    let queryString = '';
+    if (extras) {
+        for (const [key, value] of Object.entries(extras)) {
+            if (queryString === '') {
+                queryString += '?';
+            } else {
+                queryString += '&';
+            }
+            queryString += `${key}=${encodeURIComponent(value)}`;
+        }
+    }
+    window.location.href = `${url}${queryString}`;
+};
+
+export const performFirstTokenRequestAsync = (storage:any) => async (url, extras, tokenRenewMode: string, timeoutMs = 10000) => {
+    extras = extras ? { ...extras } : {};
+    extras.code_verifier = await storage.getCodeVerifierAsync();
+    const formBody = [];
+    for (const property in extras) {
+        const encodedKey = encodeURIComponent(property);
+        const encodedValue = encodeURIComponent(extras[property]);
+        formBody.push(`${encodedKey}=${encodedValue}`);
+    }
+    const formBodyString = formBody.join('&');
+    const response = await internalFetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+        },
+        body: formBodyString,
+    }, timeoutMs);
+    await Promise.all([storage.setCodeVerifierAsync(null), storage.setStateAsync(null)]);
+    if (response.status !== 200) {
+        return { success: false, status: response.status };
+    }
+    const tokens = await response.json();
+    return {
+        success: true,
+        data: {
+            state: extras.state,
+            tokens: parseOriginalTokens(tokens, null, tokenRenewMode),
+            },
+    };
+};

package/src/oidc/vanilla/route-utils.ts

@@ -18,7 +18,7 @@ export const getLocation = (href: string) => {
         }
     }
 
-    if (search) {
+    if (search.startsWith('?')) {
         search = search.slice(1);
     }
 
@@ -72,7 +72,7 @@ const parseQueryString = (queryString:string) => {
     // Convert the array of strings into an object
     for (i = 0, l = queries.length; i < l; i++) {
         temp = queries[i].split('=');
-        params[decodeURIComponent(temp[0])] = temp[1];
+        params[decodeURIComponent(temp[0])] = decodeURIComponent(temp[1]);
     }
 
     return params;

package/src/oidc/vanilla/types.ts

@@ -13,6 +13,7 @@ export type OidcConfiguration = {
     token_request_timeout?: number;
     service_worker_relative_url?:string;
     service_worker_only?:boolean;
+    service_worker_convert_all_requests_to_cors?:boolean;
     extras?:StringMap;
     token_request_extras?:StringMap;
     storage?: Storage;

package/dist/vanilla/memoryStorageBackend.d.ts

@@ -1,11 +0,0 @@
-export declare type ItemName = string | number;
-export declare class MemoryStorageBackend {
-    items: any;
-    private saveItemsAsync;
-    constructor(saveItemsAsync: any, items?: {});
-    getItem(name: ItemName): Promise<any>;
-    removeItem(name: ItemName): Promise<any>;
-    clear(): Promise<any>;
-    setItem(name: ItemName, value: any): Promise<any>;
-}
-//# sourceMappingURL=memoryStorageBackend.d.ts.map

package/dist/vanilla/memoryStorageBackend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoryStorageBackend.d.ts","sourceRoot":"","sources":["../../src/oidc/vanilla/memoryStorageBackend.ts"],"names":[],"mappings":"AAKA,oBAAY,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAEvC,qBAAa,oBAAoB;IACtB,KAAK,EAAE,GAAG,CAAC;IAClB,OAAO,CAAC,cAAc,CAAc;gBAExB,cAAc,KAAA,EAAE,KAAK,KAAK;IAUtC,OAAO,CAAC,IAAI,EAAE,QAAQ;IAItB,UAAU,CAAC,IAAI,EAAE,QAAQ;IAKzB,KAAK;IAKL,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG;CAIrC"}

package/dist/vanilla/memoryStorageBackend.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryStorageBackend = void 0;
-class MemoryStorageBackend {
-    constructor(saveItemsAsync, items = {}) {
-        this.items = items;
-        this.saveItemsAsync = saveItemsAsync;
-        this.saveItemsAsync.bind(this);
-        this.getItem.bind(this);
-        this.removeItem.bind(this);
-        this.clear.bind(this);
-        this.setItem.bind(this);
-    }
-    getItem(name) {
-        return Promise.resolve(this.items[name]);
-    }
-    removeItem(name) {
-        delete this.items[name];
-        return this.saveItemsAsync(this.items);
-    }
-    clear() {
-        this.items = {};
-        return this.saveItemsAsync(this.items);
-    }
-    setItem(name, value) {
-        this.items[name] = value;
-        return this.saveItemsAsync(this.items);
-    }
-}
-exports.MemoryStorageBackend = MemoryStorageBackend;
-//# sourceMappingURL=memoryStorageBackend.js.map

package/dist/vanilla/memoryStorageBackend.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoryStorageBackend.js","sourceRoot":"","sources":["../../src/oidc/vanilla/memoryStorageBackend.ts"],"names":[],"mappings":";;;AAOA,MAAa,oBAAoB;IAI7B,YAAY,cAAc,EAAE,KAAK,GAAG,EAAE;QAClC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAED,OAAO,CAAC,IAAc;QAClB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED,UAAU,CAAC,IAAc;QACrB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACxB,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED,KAAK;QACD,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED,OAAO,CAAC,IAAc,EAAE,KAAU;QAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QACzB,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;CACJ;AAhCD,oDAgCC"}

package/dist/vanilla/noHashQueryStringUtils.d.ts

@@ -1,8 +0,0 @@
-import { BasicQueryStringUtils, LocationLike } from '@openid/appauth';
-export declare class NoHashQueryStringUtils extends BasicQueryStringUtils {
-    parse(input: LocationLike, _useHash: boolean): import("@openid/appauth").StringMap;
-}
-export declare class HashQueryStringUtils extends BasicQueryStringUtils {
-    parse(input: LocationLike, _useHash: boolean): import("@openid/appauth").StringMap;
-}
-//# sourceMappingURL=noHashQueryStringUtils.d.ts.map

package/dist/vanilla/noHashQueryStringUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"noHashQueryStringUtils.d.ts","sourceRoot":"","sources":["../../src/oidc/vanilla/noHashQueryStringUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEtE,qBAAa,sBAAuB,SAAQ,qBAAqB;IAC7D,KAAK,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO;CAG/C;AAID,qBAAa,oBAAqB,SAAQ,qBAAqB;IAC3D,KAAK,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO;CAoB/C"}

package/dist/vanilla/noHashQueryStringUtils.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashQueryStringUtils = exports.NoHashQueryStringUtils = void 0;
-const appauth_1 = require("@openid/appauth");
-class NoHashQueryStringUtils extends appauth_1.BasicQueryStringUtils {
-    parse(input, _useHash) {
-        return super.parse(input, false /* never use hash */);
-    }
-}
-exports.NoHashQueryStringUtils = NoHashQueryStringUtils;
-const keys = ['code', 'session_state', 'state'];
-class HashQueryStringUtils extends appauth_1.BasicQueryStringUtils {
-    parse(input, _useHash) {
-        const output = super.parse(input, true /* use hash */);
-        // Fix AppAuthJs behavior
-        let propertyToDelelete = null;
-        Object.entries(output).forEach(([key, value]) => {
-            keys.forEach(k => {
-                if (key.endsWith(`?${k}`)) {
-                    output[k] = value;
-                    propertyToDelelete = key;
-                }
-            });
-        });
-        if (propertyToDelelete) {
-            delete output[propertyToDelelete];
-        }
-        return output;
-    }
-}
-exports.HashQueryStringUtils = HashQueryStringUtils;
-//# sourceMappingURL=noHashQueryStringUtils.js.map

package/dist/vanilla/noHashQueryStringUtils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"noHashQueryStringUtils.js","sourceRoot":"","sources":["../../src/oidc/vanilla/noHashQueryStringUtils.ts"],"names":[],"mappings":";;;AAAA,6CAAsE;AAEtE,MAAa,sBAAuB,SAAQ,+BAAqB;IAC7D,KAAK,CAAC,KAAmB,EAAE,QAAiB;QACxC,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC;IAC1D,CAAC;CACJ;AAJD,wDAIC;AAED,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;AAEhD,MAAa,oBAAqB,SAAQ,+BAAqB;IAC3D,KAAK,CAAC,KAAmB,EAAE,QAAiB;QACxC,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAEvD,yBAAyB;QACzB,IAAI,kBAAkB,GAAG,IAAI,CAAC;QAC9B,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YAC5C,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBACb,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;oBACvB,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;oBAClB,kBAAkB,GAAG,GAAG,CAAC;iBAC5B;YACL,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QAEH,IAAI,kBAAkB,EAAE;YACpB,OAAO,MAAM,CAAC,kBAAkB,CAAC,CAAC;SACrC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AArBD,oDAqBC"}

package/src/oidc/vanilla/memoryStorageBackend.ts

@@ -1,40 +0,0 @@
-
-interface SaveItemsFn {
-    (items:any):Promise<any>;
-}
-
-export type ItemName = string | number;
-
-export class MemoryStorageBackend {
-    public items: any;
-    private saveItemsAsync: SaveItemsFn;
-
-    constructor(saveItemsAsync, items = {}) {
-        this.items = items;
-        this.saveItemsAsync = saveItemsAsync;
-        this.saveItemsAsync.bind(this);
-        this.getItem.bind(this);
-        this.removeItem.bind(this);
-        this.clear.bind(this);
-        this.setItem.bind(this);
-    }
-
-    getItem(name: ItemName) {
-        return Promise.resolve(this.items[name]);
-    }
-
-    removeItem(name: ItemName) {
-        delete this.items[name];
-        return this.saveItemsAsync(this.items);
-    }
-
-    clear() {
-        this.items = {};
-        return this.saveItemsAsync(this.items);
-    }
-
-    setItem(name: ItemName, value: any) {
-        this.items[name] = value;
-        return this.saveItemsAsync(this.items);
-    }
-}

package/src/oidc/vanilla/noHashQueryStringUtils.ts

@@ -1,32 +0,0 @@
-import { BasicQueryStringUtils, LocationLike } from '@openid/appauth';
-
-export class NoHashQueryStringUtils extends BasicQueryStringUtils {
-    parse(input: LocationLike, _useHash: boolean) {
-        return super.parse(input, false /* never use hash */);
-    }
-}
-
-const keys = ['code', 'session_state', 'state'];
-
-export class HashQueryStringUtils extends BasicQueryStringUtils {
-    parse(input: LocationLike, _useHash: boolean) {
-        const output = super.parse(input, true /* use hash */);
-
-        // Fix AppAuthJs behavior
-        let propertyToDelelete = null;
-        Object.entries(output).forEach(([key, value]) => {
-            keys.forEach(k => {
-                if (key.endsWith(`?${k}`)) {
-                    output[k] = value;
-                    propertyToDelelete = key;
-                }
-            });
-        });
-
-        if (propertyToDelelete) {
-            delete output[propertyToDelelete];
-        }
-
-        return output;
-    }
-}