@axa-fr/oidc-client 6.26.6

package/src/timer.ts

@@ -0,0 +1,163 @@
+const timer = (function () {
+    const workerPort = (function () {
+        let worker;
+        let blobURL;
+
+        const workerCode = function () {
+            const innerIdsByOuterIds = {};
+
+            const methods = {
+                setTimeout: function (port, id, timeout) {
+                    innerIdsByOuterIds[id] = setTimeout(function () {
+                        port.postMessage(id);
+                        innerIdsByOuterIds[id] = null;
+                    }, timeout);
+                },
+
+                setInterval: function (port, id, timeout) {
+                    innerIdsByOuterIds[id] = setInterval(function () {
+                        port.postMessage(id);
+                    }, timeout);
+                },
+
+                clearTimeout: function (port, id) {
+                    clearTimeout(innerIdsByOuterIds[id]);
+                    innerIdsByOuterIds[id] = null;
+                },
+
+                clearInterval: function (port, id) {
+                    clearInterval(innerIdsByOuterIds[id]);
+                    innerIdsByOuterIds[id] = null;
+                },
+            };
+
+            function onMessage(port, event) {
+                const method = event.data[0];
+                const id = event.data[1];
+                const option = event.data[2];
+
+                if (methods[method]) {
+                    methods[method](port, id, option);
+                }
+            }
+
+            // For Dedicated Worker
+            this.onmessage = function (event) {
+                onMessage(self, event);
+            };
+
+            // For Shared Worker
+            this.onconnect = function (event) {
+                const port = event.ports[0];
+
+                port.onmessage = function (event) {
+                    onMessage(port, event);
+                };
+            };
+        }.toString();
+
+        try {
+            const blob = new Blob(['(', workerCode, ')()'], { type: 'application/javascript' });
+            blobURL = URL.createObjectURL(blob);
+        } catch (error) {
+            return null;
+        }
+        const isInsideBrowser = (typeof process === 'undefined');
+        try {
+            if (SharedWorker) {
+                worker = new SharedWorker(blobURL);
+               return worker.port;
+            }
+        } catch (error) {
+            if (isInsideBrowser) {
+                console.warn('SharedWorker not available');
+            }
+        }
+        try {
+            if (Worker) {
+                worker = new Worker(blobURL);
+                return worker;
+            }
+        } catch (error) {
+            if (isInsideBrowser) {
+                console.warn('Worker not available');
+            }
+        }
+
+        return null;
+    }());
+
+    if (!workerPort) {
+        // In NextJS with SSR (Server Side Rendering) during rending in Node JS, the window object is undefined,
+        // the global object is used instead as it is the closest approximation of a browsers window object.
+        const bindContext = (typeof window === 'undefined') ? global : window;
+
+        return {
+            setTimeout: setTimeout.bind(bindContext),
+            clearTimeout: clearTimeout.bind(bindContext),
+            setInterval: setInterval.bind(bindContext),
+            clearInterval: clearInterval.bind(bindContext),
+        };
+    }
+
+    const getId = (function () {
+        let currentId = 0;
+
+        return function () {
+            currentId++;
+            return currentId;
+        };
+    }());
+
+    const timeoutCallbacksById = {};
+    const intervalCallbacksById = {};
+
+    workerPort.onmessage = function (event) {
+        const id = event.data;
+
+        const timeoutCallback = timeoutCallbacksById[id];
+        if (timeoutCallback) {
+            timeoutCallback();
+            timeoutCallbacksById[id] = null;
+            return;
+        }
+
+        const intervalCallback = intervalCallbacksById[id];
+        if (intervalCallback) {
+            intervalCallback();
+        }
+    };
+
+    function setTimeoutWorker(callback, timeout) {
+        const id = getId();
+        workerPort.postMessage(['setTimeout', id, timeout]);
+        timeoutCallbacksById[id] = callback;
+        return id;
+    }
+
+    function clearTimeoutWorker(id) {
+        workerPort.postMessage(['clearTimeout', id]);
+        timeoutCallbacksById[id] = null;
+    }
+
+    function setIntervalWorker(callback, timeout) {
+        const id = getId();
+        workerPort.postMessage(['setInterval', id, timeout]);
+        intervalCallbacksById[id] = callback;
+        return id;
+    }
+
+    function clearIntervalWorker(id) {
+        workerPort.postMessage(['clearInterval', id]);
+        intervalCallbacksById[id] = null;
+    }
+
+    return {
+        setTimeout: setTimeoutWorker,
+        clearTimeout: clearTimeoutWorker,
+        setInterval: setIntervalWorker,
+        clearInterval: clearIntervalWorker,
+    };
+}());
+
+export default timer;

package/src/types.ts

@@ -0,0 +1,41 @@
+export type Fetch = typeof window.fetch;
+
+export type LogoutToken = 'access_token' | 'refresh_token';
+
+export type OidcConfiguration = {
+    client_id: string;
+    redirect_uri: string;
+    silent_redirect_uri?:string;
+    silent_login_uri?:string;
+    silent_login_timeout?:number;
+    scope: string;
+    authority: string;
+    authority_time_cache_wellknowurl_in_second?: number;
+    authority_timeout_wellknowurl_in_millisecond?: number;
+    authority_configuration?: AuthorityConfiguration;
+    refresh_time_before_tokens_expiration_in_second?: number;
+    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;
+    monitor_session?: boolean;
+    token_renew_mode?: string;
+    logout_tokens_to_invalidate?:Array<LogoutToken>;
+};
+
+export interface StringMap {
+    [key: string]: string;
+}
+
+export interface AuthorityConfiguration {
+    authorization_endpoint: string;
+    token_endpoint: string;
+    revocation_endpoint: string;
+    end_session_endpoint?: string;
+    userinfo_endpoint?: string;
+    check_session_iframe?:string;
+    issuer:string;
+}

package/src/user.ts

@@ -0,0 +1,40 @@
+import { sleepAsync } from './initWorker.js';
+import { isTokensValid } from './parseTokens.js';
+
+export const userInfoAsync = (oidc) => async (noCache = false) => {
+    if (oidc.userInfo != null && !noCache) {
+        return oidc.userInfo;
+    }
+
+    // We wait the synchronisation before making a request
+    while (oidc.tokens && !isTokensValid(oidc.tokens)) {
+        await sleepAsync(200);
+    }
+
+    if (!oidc.tokens) {
+        return null;
+    }
+    const accessToken = oidc.tokens.accessToken;
+    if (!accessToken) {
+        return null;
+    }
+
+    const oidcServerConfiguration = await oidc.initAsync(oidc.configuration.authority, oidc.configuration.authority_configuration);
+    const url = oidcServerConfiguration.userInfoEndpoint;
+    const fetchUserInfo = async (accessToken) => {
+        const res = await fetch(url, {
+            headers: {
+                authorization: `Bearer ${accessToken}`,
+            },
+        });
+
+        if (res.status !== 200) {
+            return null;
+        }
+
+        return res.json();
+    };
+    const userInfo = await fetchUserInfo(accessToken);
+    oidc.userInfo = userInfo;
+    return userInfo;
+};

package/src/vanillaOidc.ts

@@ -0,0 +1,108 @@
+import { LoginCallback, Oidc } from './oidc.js';
+import { getValidTokenAsync, Tokens, ValidToken } from './parseTokens.js';
+import { Fetch, OidcConfiguration, StringMap } from './types.js';
+
+export interface EventSubscriber {
+    (name: string, data:any);
+}
+
+export class VanillaOidc {
+    private _oidc: Oidc;
+    constructor(oidc: Oidc) {
+        this._oidc = oidc;
+    }
+
+    subscribeEvents(func:EventSubscriber):string {
+        return this._oidc.subscribeEvents(func);
+    }
+
+    removeEventSubscription(id:string):void {
+        this._oidc.removeEventSubscription(id);
+    }
+
+    publishEvent(eventName:string, data:any) : void {
+        this._oidc.publishEvent(eventName, data);
+    }
+
+    static getOrCreate = (getFetch : () => Fetch) => (configuration:OidcConfiguration, name = 'default'): VanillaOidc => {
+        return new VanillaOidc(Oidc.getOrCreate(getFetch)(configuration, name));
+    };
+
+    static get(name = 'default'):VanillaOidc {
+        return new VanillaOidc(Oidc.get(name));
+    }
+
+    static eventNames = Oidc.eventNames;
+    tryKeepExistingSessionAsync():Promise<boolean> {
+        return this._oidc.tryKeepExistingSessionAsync();
+    }
+
+    loginAsync(callbackPath:string = undefined, extras:StringMap = null, isSilentSignin = false, scope:string = undefined, silentLoginOnly = false):Promise<unknown> {
+        return this._oidc.loginAsync(callbackPath, extras, isSilentSignin, scope, silentLoginOnly);
+    }
+
+    logoutAsync(callbackPathOrUrl: string | null | undefined = undefined, extras: StringMap = null):Promise<void> {
+        return this._oidc.logoutAsync(callbackPathOrUrl, extras);
+    }
+
+    silentLoginCallbackAsync():Promise<void> {
+        return this._oidc.silentLoginCallbackAsync();
+    }
+
+    renewTokensAsync(extras:StringMap = null):Promise<void> {
+        return this._oidc.renewTokensAsync(extras);
+    }
+
+    loginCallbackAsync():Promise<LoginCallback> {
+        return this._oidc.loginCallbackWithAutoTokensRenewAsync();
+    }
+
+    get tokens():Tokens {
+        return this._oidc.tokens;
+    }
+
+    get configuration():OidcConfiguration {
+        return this._oidc.configuration;
+    }
+
+    async getValidTokenAsync(waitMs = 200, numberWait = 50): Promise<ValidToken> {
+        return getValidTokenAsync(this._oidc, waitMs, numberWait);
+    }
+
+    async userInfoAsync<T extends OidcUserInfo = OidcUserInfo>(noCache = false):Promise<T> {
+        return this._oidc.userInfoAsync(noCache);
+    }
+}
+
+export interface OidcUserInfo {
+    sub: string;
+    name?: string;
+    given_name?: string;
+    family_name?: string;
+    middle_name?: string;
+    nickname?: string;
+    preferred_username?: string;
+    profile?: string;
+    picture?: string;
+    website?: string;
+    email?: string;
+    email_verified?: boolean;
+    gender?: string;
+    birthdate?: string;
+    zoneinfo?: string;
+    locale?: string;
+    phone_number?: string;
+    phone_number_verified?: boolean;
+    address?: OidcAddressClaim;
+    updated_at?: number;
+    groups?: string[];
+}
+
+export interface OidcAddressClaim {
+    formatted?: string;
+    street_address?: string;
+    locality?: string;
+    region?: string;
+    postal_code?: string;
+    country?: string;
+}