@axa-fr/react-oidc 5.14.0 → 6.0.0-alpha0

package/src/oidc/vanilla/checkSessionIFrame.ts

@@ -0,0 +1,82 @@
+const DefaultInterval = 2000;
+
+const Log = console;
+
+export class CheckSessionIFrame {
+    private _client_id: any;
+    private _callback: any;
+    private _url: any;
+    private _interval: number;
+    private _stopOnError: boolean;
+    private _frame_origin: string;
+    private _frame: HTMLIFrameElement;
+    private _boundMessageEvent: any;
+    private _timer: number;
+    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);
+        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";
+        // @ts-ignore
+        this._frame.width = 0;
+        // @ts-ignore
+        this._frame.height = 0;
+
+        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);
+        });
+    }
+    _message(e) {
+        if (e.origin === this._frame_origin &&
+            e.source === this._frame.contentWindow
+        ) {
+            if (e.data === "error") {
+                console.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");
+                this.stop();
+                this._callback();
+            }
+            else {
+                Log.debug("CheckSessionIFrame: " + e.data + " message from check session op iframe");
+            }
+        }
+    }
+    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);
+            };
+            send();
+            this._timer = window.setInterval(send, this._interval);
+    }
+
+    stop() {
+        if (this._timer) {
+            Log.debug("CheckSessionIFrame.stop");
+            window.clearInterval(this._timer);
+            this._timer = null;
+        }
+    }
+}

package/src/oidc/vanilla/initSession.ts

@@ -1,36 +1,48 @@
-export const initSession = (configurationName, storage=sessionStorage) => {
+export const initSession = (configurationName, redirectUri, storage=sessionStorage) => {
 
     const saveItemsAsync =(items) =>{
-        storage[`oidc_items.${configurationName}`] = JSON.stringify(items);
+        storage[`oidc_items.${configurationName}:${redirectUri}`] = JSON.stringify(items);
         return Promise.resolve();
     }
 
     const loadItemsAsync=() =>{
-        return Promise.resolve(JSON.parse(storage[`oidc_items.${configurationName}`]));
+        return Promise.resolve(JSON.parse(storage[`oidc_items.${configurationName}:${redirectUri}`]));
     }
 
     const clearAsync=() =>{
-        storage[`oidc.${configurationName}`] = JSON.stringify({tokens:null});
+        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens:null});
         return Promise.resolve();
     }
 
     const initAsync=async () => {
-        if(!storage[`oidc.${configurationName}`]){
-            storage[`oidc.${configurationName}`] = JSON.stringify({tokens:null});
+        if(!storage[`oidc.${configurationName}:${redirectUri}`]){
+            storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens:null});
+            return {tokens:null};
         }
-        return Promise.resolve({ tokens : JSON.parse(storage[`oidc.${configurationName}`]).tokens });
+        return Promise.resolve({ tokens : JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]).tokens });
     }
 
     const setTokens = (tokens) => {
-        storage[`oidc.${configurationName}`] = JSON.stringify({tokens});
+        //console.log("setTokens");
+        //console.log(tokens);
+        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens});
+    }
+
+    const setSessionState = (sessionState) => {
+        storage[`oidc.session_state.${configurationName}:${redirectUri}`] = sessionState;
+    }
+    
+    const getSessionState= () =>{
+        return storage[`oidc.session_state.${configurationName}:${redirectUri}`];
     }
 
     const getTokens = () => {
-        if(!storage[`oidc.${configurationName}`]){
+       
+        if(!storage[`oidc.${configurationName}:${redirectUri}`]){
             return null;
         }
-        return JSON.stringify({ tokens : JSON.parse(storage[`oidc.${configurationName}`]).tokens });
+        return JSON.stringify({ tokens : JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]).tokens });
     }
 
-    return { saveItemsAsync, loadItemsAsync, clearAsync, initAsync, setTokens, getTokens };
+    return { saveItemsAsync, loadItemsAsync, clearAsync, initAsync, setTokens, getTokens, setSessionState, getSessionState };
 }

package/src/oidc/vanilla/initWorker.ts

@@ -102,6 +102,10 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
     const loadItemsAsync=() =>{
         return sendMessageAsync(registration)({type: "loadItems", data: null, configurationName});
     }
+    
+    const unregisterAsync = async () => {
+        await registration.unregister()
+    }
 
     const getAccessTokenPayloadAsync=async () => {
         const result = await sendMessageAsync(registration)({
@@ -123,7 +127,7 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
             configurationName
         });
         // @ts-ignore
-        return { tokens : result.tokens};
+        return { tokens : result.tokens, isLogin: result.isLogin};
     }
     
     const startKeepAliveServiceWorker = () => {
@@ -133,6 +137,16 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
         }
     }
 
+    const setSessionStateAsync = (sessionState) => {
+        return sendMessageAsync(registration)({type: "setSessionState", data: {sessionState}, configurationName});
+    }
+
+    const getSessionStateAsync= async () => {
+        const result = await sendMessageAsync(registration)({type: "getSessionState", data: null, configurationName});
+        // @ts-ignore
+        return result.sessionState;
+    }
+
     return { 
         saveItemsAsync, 
         loadItemsAsync, 
@@ -140,6 +154,9 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
         initAsync, 
         getAccessTokenPayloadAsync,
         startKeepAliveServiceWorker,
-        isServiceWorkerProxyActiveAsync
+        isServiceWorkerProxyActiveAsync,
+        setSessionStateAsync,
+        getSessionStateAsync,
+        unregisterAsync,
     };
 }