@axa-fr/react-oidc 6.9.6 → 6.10.0

package/src/oidc/vanilla/checkSessionIFrame.ts

@@ -1,4 +1,4 @@
-const DefaultInterval = 2000;
+const DefaultInterval = 2000;
 
 const Log = console;
 
@@ -12,18 +12,18 @@ export class CheckSessionIFrame {
     private readonly _frame: HTMLIFrameElement;
     private _boundMessageEvent: any;
     private _timer: number;
-    constructor(callback, client_id, url, interval=DefaultInterval, stopOnError = true) {
+    constructor(callback, client_id, url, interval = DefaultInterval, stopOnError = true) {
         this._callback = callback;
         this._client_id = client_id;
         this._url = url;
         this._interval = interval || DefaultInterval;
         this._stopOnError = stopOnError;
-        const idx = url.indexOf("/", url.indexOf("//") + 2);
+        const idx = url.indexOf('/', url.indexOf('//') + 2);
         this._frame_origin = url.substr(0, idx);
-        this._frame = window.document.createElement("iframe");
-        this._frame.style.visibility = "hidden";
-        this._frame.style.position = "absolute";
-        this._frame.style.display = "none";
+        this._frame = window.document.createElement('iframe');
+        this._frame.style.visibility = 'hidden';
+        this._frame.style.position = 'absolute';
+        this._frame.style.display = 'none';
         // @ts-ignore
         this._frame.width = 0;
         // @ts-ignore
@@ -31,42 +31,43 @@ export class CheckSessionIFrame {
 
         this._frame.src = url;
     }
+
     load() {
         return new Promise<void>((resolve) => {
             this._frame.onload = () => {
                 resolve();
-            }
+            };
             window.document.body.appendChild(this._frame);
             this._boundMessageEvent = this._message.bind(this);
-            window.addEventListener("message", this._boundMessageEvent, false);
+            window.addEventListener('message', this._boundMessageEvent, false);
         });
     }
+
     _message(e) {
         if (e.origin === this._frame_origin &&
             e.source === this._frame.contentWindow
         ) {
-            if (e.data === "error") {
-                Log.error("CheckSessionIFrame: error message from check session op iframe");
+            if (e.data === 'error') {
+                Log.error('CheckSessionIFrame: error message from check session op iframe');
                 if (this._stopOnError) {
                     this.stop();
                 }
-            }
-            else if (e.data === "changed") {
-                Log.debug(e)
-                Log.debug("CheckSessionIFrame: changed message from check session op iframe");
+            } else if (e.data === 'changed') {
+                Log.debug(e);
+                Log.debug('CheckSessionIFrame: changed message from check session op iframe');
                 this.stop();
                 this._callback();
-            }
-            else {
-                Log.debug("CheckSessionIFrame: " + e.data + " message from check session op iframe");
+            } else {
+                Log.debug('CheckSessionIFrame: ' + e.data + ' message from check session op iframe');
             }
         }
     }
+
     start(session_state) {
-            Log.debug("CheckSessionIFrame.start :" + session_state);
+            Log.debug('CheckSessionIFrame.start :' + session_state);
             this.stop();
-            let send = () => {
-                this._frame.contentWindow.postMessage(this._client_id + " " + session_state, this._frame_origin);
+            const send = () => {
+                this._frame.contentWindow.postMessage(this._client_id + ' ' + session_state, this._frame_origin);
             };
             send();
             this._timer = window.setInterval(send, this._interval);
@@ -74,9 +75,9 @@ export class CheckSessionIFrame {
 
     stop() {
         if (this._timer) {
-            Log.debug("CheckSessionIFrame.stop");
+            Log.debug('CheckSessionIFrame.stop');
             window.clearInterval(this._timer);
             this._timer = null;
         }
     }
-}
+}

package/src/oidc/vanilla/index.ts

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

package/src/oidc/vanilla/initSession.ts

@@ -1,67 +1,66 @@
-export const initSession = (configurationName, redirectUri, storage=sessionStorage) => {
-
-    const saveItemsAsync =(items) =>{
+export const initSession = (configurationName, redirectUri, storage = sessionStorage) => {
+    const saveItemsAsync = (items) => {
         storage[`oidc_items.${configurationName}:${redirectUri}`] = JSON.stringify(items);
         return Promise.resolve();
-    }
+    };
 
-    const loadItemsAsync=() =>{
+    const loadItemsAsync = () => {
         return Promise.resolve(JSON.parse(storage[`oidc_items.${configurationName}:${redirectUri}`]));
-    }
+    };
 
-    const clearAsync=(status) =>{
-        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens:null, status});
+    const clearAsync = (status) => {
+        storage[`oidc.${configurationName}:${redirectUri}`] = 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});
-            return {tokens:null, status:null};
+    const initAsync = async () => {
+        if (!storage[`oidc.${configurationName}:${redirectUri}`]) {
+            storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({ tokens: null, status: null });
+            return { tokens: null, status: null };
         }
         const data = JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]);
-        return Promise.resolve({ tokens : data.tokens, status: data.status });
-    }
+        return Promise.resolve({ tokens: data.tokens, status: data.status });
+    };
 
     const setTokens = (tokens) => {
-        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens});
-    }
+        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({ tokens });
+    };
 
     const setSessionState = (sessionState) => {
         storage[`oidc.session_state.${configurationName}:${redirectUri}`] = sessionState;
-    }
-    
-    const getSessionState= () =>{
+    };
+
+    const getSessionState = () => {
         return storage[`oidc.session_state.${configurationName}:${redirectUri}`];
-    }
+    };
 
     const setNonceAsync = (nonce) => {
         localStorage[`oidc.nonce.${configurationName}:${redirectUri}`] = nonce.nonce;
-    }
+    };
 
-    const getNonceAsync= async () => {
+    const getNonceAsync = async () => {
         // @ts-ignore
-        const result =  {nonce: localStorage[`oidc.nonce.${configurationName}:${redirectUri}`]};
+        const result = { nonce: localStorage[`oidc.nonce.${configurationName}:${redirectUri}`] };
         return result;
-    }
+    };
 
     const getTokens = () => {
-        if(!storage[`oidc.${configurationName}:${redirectUri}`]){
+        if (!storage[`oidc.${configurationName}:${redirectUri}`]) {
             return null;
         }
-        return JSON.stringify({ tokens : JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]).tokens });
-    }
+        return JSON.stringify({ tokens: JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]).tokens });
+    };
 
     return {
-        saveItemsAsync, 
-        loadItemsAsync, 
-        clearAsync, 
-        initAsync, 
-        setTokens, 
-        getTokens, 
-        setSessionState, 
+        saveItemsAsync,
+        loadItemsAsync,
+        clearAsync,
+        initAsync,
+        setTokens,
+        getTokens,
+        setSessionState,
         getSessionState,
         setNonceAsync,
-        getNonceAsync
+        getNonceAsync,
     };
-}
+};

package/src/oidc/vanilla/initWorker.ts

@@ -1,64 +1,65 @@
-import timer from "./timer"
-import {parseOriginalTokens} from "./parseTokens";
-import {OidcConfiguration} from "./oidc";
+import { OidcConfiguration } from './oidc';
+import { parseOriginalTokens } from './parseTokens';
+import timer from './timer';
 
 function get_browser() {
-    let ua = navigator.userAgent, tem,
-        M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
-    if(/trident/i.test(M[1])){
-        tem=/\brv[ :]+(\d+)/g.exec(ua) || [];
-        return {name:'ie',version:(tem[1]||'')};
-    }
-    if(M[1]==='Chrome'){
-        tem=ua.match(/\bOPR|Edge\/(\d+)/);
-       
-        if(tem!=null) {
+    const ua = navigator.userAgent; let tem;
+        let M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+    if (/trident/i.test(M[1])) {
+        tem = /\brv[ :]+(\d+)/g.exec(ua) || [];
+        return { name: 'ie', version: (tem[1] || '') };
+    }
+    if (M[1] === 'Chrome') {
+        tem = ua.match(/\bOPR|Edge\/(\d+)/);
+
+        if (tem != null) {
             let version = tem[1];
-            if(!version){
-                const splits = ua.split(tem[0]+"/");
-                if(splits.length>1){
+            if (!version) {
+                const splits = ua.split(tem[0] + '/');
+                if (splits.length > 1) {
                     version = splits[1];
                 }
             }
-            
-            return {name:'opera', version};
+
+            return { name: 'opera', version };
         }
     }
-    M=M[2]? [M[1], M[2]]: [navigator.appName, navigator.appVersion, '-?'];
-    if((tem=ua.match(/version\/(\d+)/i))!=null) {M.splice(1,1,tem[1]);}
+    M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?'];
+    if ((tem = ua.match(/version\/(\d+)/i)) != null) { M.splice(1, 1, tem[1]); }
     return {
         name: M[0].toLowerCase(),
-        version: M[1]
+        version: M[1],
     };
 }
 
 let keepAliveServiceWorkerTimeoutId = null;
 
 export const sleepAsync = (milliseconds) => {
-    return new Promise(resolve => timer.setTimeout(resolve, milliseconds))
-}
+    return new Promise(resolve => timer.setTimeout(resolve, milliseconds));
+};
 
 const keepAlive = () => {
     try {
         const promise = fetch('/OidcKeepAliveServiceWorker.json');
-        promise.catch(error => {console.log(error)});
+        promise.catch(error => { console.log(error); });
         sleepAsync(230 * 1000).then(keepAlive);
-    } catch (error){console.log(error)}
-}
+    } catch (error) { console.log(error); }
+};
 
 const isServiceWorkerProxyActiveAsync = () => {
     try {
         return fetch('/OidcKeepAliveServiceWorker.json', {
             headers: {
-                'oidc-vanilla': "true"
-            }})
+                'oidc-vanilla': 'true',
+            },
+})
             .then((response) => {
                 return response.statusText === 'oidc-service-worker';
-            }).catch(error => {console.log(error)});
-    } catch (error){console.log(error)}
+            }).catch(error => { console.log(error); });
+    } catch (error) { console.log(error); }
 };
 
-const sendMessageAsync = (registration) => (data) =>{
+const sendMessageAsync = (registration) => (data) => {
     return new Promise(function(resolve, reject) {
         const messageChannel = new MessageChannel();
         messageChannel.port1.onmessage = function (event) {
@@ -70,95 +71,93 @@ const sendMessageAsync = (registration) => (data) =>{
         };
         registration.active.postMessage(data, [messageChannel.port2]);
     });
-}
+};
 
 export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName) => {
-    
-    if(typeof window === "undefined" || typeof navigator === "undefined" || !navigator.serviceWorker||!serviceWorkerRelativeUrl){
+    if (typeof window === 'undefined' || typeof navigator === 'undefined' || !navigator.serviceWorker || !serviceWorkerRelativeUrl) {
         return null;
     }
-    const {name, version} = get_browser();
-    if(name == "chrome" && parseInt(version)<90){
+    const { name, version } = get_browser();
+    if (name === 'chrome' && parseInt(version) < 90) {
         return null;
     }
-    if(name == "opera"){
-        if(!version) {
+    if (name === 'opera') {
+        if (!version) {
             return null;
         }
-        if(parseInt(version.split(".")[0])< 80) {
+        if (parseInt(version.split('.')[0]) < 80) {
             return null;
         }
     }
-    if(name == "ie"){
+    if (name === 'ie') {
         return null;
     }
 
     const registration = await navigator.serviceWorker.register(serviceWorkerRelativeUrl);
 
     try {
-        await navigator.serviceWorker.ready
-    }
-    catch(err) {
+        await navigator.serviceWorker.ready;
+    } catch (err) {
         return null;
     }
-    
-    const saveItemsAsync =(items) =>{
-            return sendMessageAsync(registration)({type: "saveItems", data: items, configurationName});
-    }
-    
-    const loadItemsAsync=() =>{
-        return sendMessageAsync(registration)({type: "loadItems", data: null, configurationName});
-    }
-    
+
+    const saveItemsAsync = (items) => {
+            return sendMessageAsync(registration)({ type: 'saveItems', data: items, configurationName });
+    };
+
+    const loadItemsAsync = () => {
+        return sendMessageAsync(registration)({ type: 'loadItems', data: null, configurationName });
+    };
+
     const unregisterAsync = async () => {
         return await registration.unregister();
-    }
-    
-    const clearAsync=(status) =>{
-        return sendMessageAsync(registration)({type: "clear", data: {status}, configurationName});
-    }
-    const initAsync= async (oidcServerConfiguration, where, oidcConfiguration:OidcConfiguration) => {
+    };
+
+    const clearAsync = (status) => {
+        return sendMessageAsync(registration)({ type: 'clear', data: { status }, configurationName });
+    };
+    const initAsync = async (oidcServerConfiguration, where, oidcConfiguration:OidcConfiguration) => {
         const result = await sendMessageAsync(registration)({
-            type: "init",
-            data: {oidcServerConfiguration, where, oidcConfiguration},
-            configurationName
+            type: 'init',
+            data: { oidcServerConfiguration, where, oidcConfiguration },
+            configurationName,
         });
         // @ts-ignore
-        return { tokens : parseOriginalTokens(result.tokens, null, oidcConfiguration.token_renew_mode), status: result.status};
-    }
-    
+        return { tokens: parseOriginalTokens(result.tokens, null, oidcConfiguration.token_renew_mode), status: result.status };
+    };
+
     const startKeepAliveServiceWorker = () => {
         if (keepAliveServiceWorkerTimeoutId == null) {
-            keepAliveServiceWorkerTimeoutId = "not_null";
+            keepAliveServiceWorkerTimeoutId = 'not_null';
             keepAlive();
         }
-    }
+    };
 
     const setSessionStateAsync = (sessionState) => {
-        return sendMessageAsync(registration)({type: "setSessionState", data: {sessionState}, configurationName});
-    }
+        return sendMessageAsync(registration)({ type: 'setSessionState', data: { sessionState }, configurationName });
+    };
 
-    const getSessionStateAsync= async () => {
-        const result = await sendMessageAsync(registration)({type: "getSessionState", data: null, configurationName});
+    const getSessionStateAsync = async () => {
+        const result = await sendMessageAsync(registration)({ type: 'getSessionState', data: null, configurationName });
         // @ts-ignore
         return result.sessionState;
-    }
+    };
 
     const setNonceAsync = (nonce) => {
-        return sendMessageAsync(registration)({type: "setNonce", data: {nonce}, configurationName});
-    }
+        return sendMessageAsync(registration)({ type: 'setNonce', data: { nonce }, configurationName });
+    };
     const NONCE_TOKEN = 'NONCE_SECURED_BY_OIDC_SERVICE_WORKER';
-    const getNonceAsync= async () => {
+    const getNonceAsync = async () => {
         // @ts-ignore
-        const keyNonce = NONCE_TOKEN + '_'+ configurationName;
-        return {nonce:keyNonce};
-    }
+        const keyNonce = NONCE_TOKEN + '_' + configurationName;
+        return { nonce: keyNonce };
+    };
 
-    return { 
-        saveItemsAsync, 
-        loadItemsAsync, 
-        clearAsync, 
-        initAsync, 
+    return {
+        saveItemsAsync,
+        loadItemsAsync,
+        clearAsync,
+        initAsync,
         startKeepAliveServiceWorker,
         isServiceWorkerProxyActiveAsync,
         setSessionStateAsync,
@@ -167,4 +166,4 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
         getNonceAsync,
         unregisterAsync,
     };
-}
+};

package/src/oidc/vanilla/memoryStorageBackend.ts

@@ -1,6 +1,13 @@
-export class MemoryStorageBackend {
+
+interface SaveItemsFn {
+    (items:any):Promise<any>;
+}
+
+export type ItemName = string | number;
+
+export class MemoryStorageBackend {
     public items: any;
-    private saveItemsAsync: Function;
+    private saveItemsAsync: SaveItemsFn;
 
     constructor(saveItemsAsync, items = {}) {
         this.items = items;
@@ -12,11 +19,11 @@
         this.setItem.bind(this);
     }
 
-    getItem(name) {
+    getItem(name: ItemName) {
         return Promise.resolve(this.items[name]);
     }
 
-    removeItem(name) {
+    removeItem(name: ItemName) {
         delete this.items[name];
         return this.saveItemsAsync(this.items);
     }
@@ -26,8 +33,8 @@
         return this.saveItemsAsync(this.items);
     }
 
-    setItem(name, value) {
+    setItem(name: ItemName, value: any) {
         this.items[name] = value;
         return this.saveItemsAsync(this.items);
     }
-}
+}

package/src/oidc/vanilla/noHashQueryStringUtils.ts

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