@axa-fr/oidc-client 7.22.18 → 7.22.19

package/src/silentLogin.ts

@@ -4,157 +4,175 @@ import { autoRenewTokens } from './renewTokens.js';
 import timer from './timer.js';
 import { OidcConfiguration, StringMap } from './types.js';
 export type SilentLoginResponse = {
-    tokens:Tokens;
-    sessionState:string;
-    error:string;
+  tokens: Tokens;
+  sessionState: string;
+  error: string;
 };
 
 // eslint-disable-next-line @typescript-eslint/ban-types
-export const _silentLoginAsync = (configurationName:string, configuration:OidcConfiguration, publishEvent:Function) => (extras:StringMap = null, state:string = null, scope:string = null):Promise<SilentLoginResponse> => {
+export const _silentLoginAsync =
+  (configurationName: string, configuration: OidcConfiguration, publishEvent: Function) =>
+  (
+    extras: StringMap = null,
+    state: string = null,
+    scope: string = null,
+  ): Promise<SilentLoginResponse> => {
     if (!configuration.silent_redirect_uri || !configuration.silent_login_uri) {
-        return Promise.resolve(null);
+      return Promise.resolve(null);
     }
 
     try {
-        publishEvent(eventNames.silentLoginAsync_begin, {});
-        let queries = '';
+      publishEvent(eventNames.silentLoginAsync_begin, {});
+      let queries = '';
 
-        if (state) {
-            if (extras == null) {
-                extras = {};
-            }
-            extras.state = state;
+      if (state) {
+        if (extras == null) {
+          extras = {};
         }
+        extras.state = state;
+      }
 
-        if (scope) {
-            if (extras == null) {
-                extras = {};
-            }
-            extras.scope = scope;
+      if (scope) {
+        if (extras == null) {
+          extras = {};
         }
-
-        if (extras != null) {
-            for (const [key, value] of Object.entries(extras)) {
-                if (queries === '') {
-                    queries = `?${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-                } else {
-                    queries += `&${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-                }
-            }
+        extras.scope = scope;
+      }
+
+      if (extras != null) {
+        for (const [key, value] of Object.entries(extras)) {
+          if (queries === '') {
+            queries = `?${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+          } else {
+            queries += `&${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+          }
         }
-        const link = configuration.silent_login_uri + queries;
-        const idx = link.indexOf('/', link.indexOf('//') + 2);
-        const iFrameOrigin = link.substring(0, idx);
-        const iframe = document.createElement('iframe');
-        iframe.width = '0px';
-        iframe.height = '0px';
-
-        iframe.id = `${configurationName}_oidc_iframe`;
-        iframe.setAttribute('src', link);
-        document.body.appendChild(iframe);
-        return new Promise((resolve, reject) => {
-            let isResolved = false;
-
-            const clear = () => {
-                window.removeEventListener('message', listener);
-                iframe.remove();
-                isResolved = true;
-            };
-
-            const listener = (e: MessageEvent<any>) => {
-                if (e.origin === iFrameOrigin &&
-                    e.source === iframe.contentWindow
-                ) {
-                    const key = `${configurationName}_oidc_tokens:`;
-                    const key_error = `${configurationName}_oidc_error:`;
-                    const key_exception = `${configurationName}_oidc_exception:`;
-                    const data = e.data;
-
-                    if (data && typeof (data) === 'string') {
-                        if (!isResolved) {
-                            if (data.startsWith(key)) {
-                                const result = JSON.parse(e.data.replace(key, ''));
-                                publishEvent(eventNames.silentLoginAsync_end, {});
-                                resolve(result);
-                                clear();
-                            } else if (data.startsWith(key_error)) {
-                                const result = JSON.parse(e.data.replace(key_error, ''));
-                                publishEvent(eventNames.silentLoginAsync_error, result);
-                                resolve({error: 'oidc_' + result.error, tokens: null, sessionState: null});
-                                clear();
-                            } else if (data.startsWith(key_exception)) {
-                                const result = JSON.parse(e.data.replace(key_exception, ''));
-                                publishEvent(eventNames.silentLoginAsync_error, result);
-                                reject(new Error(result.error));
-                                clear();
-                            }
-
-                        }
-                    }
+      }
+      const link = configuration.silent_login_uri + queries;
+      const idx = link.indexOf('/', link.indexOf('//') + 2);
+      const iFrameOrigin = link.substring(0, idx);
+      const iframe = document.createElement('iframe');
+      iframe.width = '0px';
+      iframe.height = '0px';
+
+      iframe.id = `${configurationName}_oidc_iframe`;
+      iframe.setAttribute('src', link);
+      document.body.appendChild(iframe);
+      return new Promise((resolve, reject) => {
+        let isResolved = false;
+
+        const clear = () => {
+          window.removeEventListener('message', listener);
+          iframe.remove();
+          isResolved = true;
+        };
+
+        const listener = (e: MessageEvent) => {
+          if (e.origin === iFrameOrigin && e.source === iframe.contentWindow) {
+            const key = `${configurationName}_oidc_tokens:`;
+            const key_error = `${configurationName}_oidc_error:`;
+            const key_exception = `${configurationName}_oidc_exception:`;
+            const data = e.data;
+
+            if (data && typeof data === 'string') {
+              if (!isResolved) {
+                if (data.startsWith(key)) {
+                  const result = JSON.parse(e.data.replace(key, ''));
+                  publishEvent(eventNames.silentLoginAsync_end, {});
+                  resolve(result);
+                  clear();
+                } else if (data.startsWith(key_error)) {
+                  const result = JSON.parse(e.data.replace(key_error, ''));
+                  publishEvent(eventNames.silentLoginAsync_error, result);
+                  resolve({ error: 'oidc_' + result.error, tokens: null, sessionState: null });
+                  clear();
+                } else if (data.startsWith(key_exception)) {
+                  const result = JSON.parse(e.data.replace(key_exception, ''));
+                  publishEvent(eventNames.silentLoginAsync_error, result);
+                  reject(new Error(result.error));
+                  clear();
                 }
-            };
-
-            try {
-                window.addEventListener('message', listener);
-
-                const silentSigninTimeout = configuration.silent_login_timeout;
-                setTimeout(() => {
-                    if (!isResolved) {
-                        clear();
-                        publishEvent(eventNames.silentLoginAsync_error, { reason: 'timeout' });
-                        reject(new Error('timeout'));
-                    }
-                }, silentSigninTimeout);
-            } catch (e) {
-                clear();
-                publishEvent(eventNames.silentLoginAsync_error, e);
-                reject(e);
+              }
             }
-        });
+          }
+        };
+
+        try {
+          window.addEventListener('message', listener);
+
+          const silentSigninTimeout = configuration.silent_login_timeout;
+          setTimeout(() => {
+            if (!isResolved) {
+              clear();
+              publishEvent(eventNames.silentLoginAsync_error, { reason: 'timeout' });
+              reject(new Error('timeout'));
+            }
+          }, silentSigninTimeout);
+        } catch (e) {
+          clear();
+          publishEvent(eventNames.silentLoginAsync_error, e);
+          reject(e);
+        }
+      });
     } catch (e) {
-        publishEvent(eventNames.silentLoginAsync_error, e);
-        throw e;
+      publishEvent(eventNames.silentLoginAsync_error, e);
+      throw e;
     }
-};
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-export const defaultSilentLoginAsync = (window, configurationName, configuration:OidcConfiguration, publishEvent :(string, any)=>void, oidc:any) => (extras:StringMap = null, scope:string = undefined) => {
+  };
+
+export const defaultSilentLoginAsync =
+  (
+    window,
+    configurationName,
+    configuration: OidcConfiguration,
+    publishEvent: (string, any) => void,
+    oidc: any,
+  ) =>
+  (extras: StringMap = null, scope: string = undefined) => {
     extras = { ...extras };
 
     const silentLoginAsync = (extras, state, scope) => {
-        return _silentLoginAsync(configurationName, configuration, publishEvent.bind(oidc))(extras, state, scope);
+      return _silentLoginAsync(configurationName, configuration, publishEvent.bind(oidc))(
+        extras,
+        state,
+        scope,
+      );
     };
 
     const loginLocalAsync = async () => {
-        if (oidc.timeoutId) {
-            timer.clearTimeout(oidc.timeoutId);
-        }
-
-        let state;
-        if (extras && 'state' in extras) {
-            state = extras.state;
-            delete extras.state;
-        }
-
-        try {
-            const extraFinal = !configuration.extras ? extras : { ...configuration.extras, ...extras };
-            const silentResult = await silentLoginAsync({
-                ...extraFinal,
-                prompt: 'none',
-            }, state, scope);
-
-            if (silentResult) {
-                oidc.tokens = silentResult.tokens;
-                publishEvent(eventNames.token_aquired, {});
-                // @ts-ignore
-                oidc.timeoutId = autoRenewTokens(oidc, oidc.tokens.expiresAt, extras);
-                return {};
-            }
-        } catch (e) {
-            return e;
+      if (oidc.timeoutId) {
+        timer.clearTimeout(oidc.timeoutId);
+      }
+
+      let state;
+      if (extras && 'state' in extras) {
+        state = extras.state;
+        delete extras.state;
+      }
+
+      try {
+        const extraFinal = !configuration.extras ? extras : { ...configuration.extras, ...extras };
+        const silentResult = await silentLoginAsync(
+          {
+            ...extraFinal,
+            prompt: 'none',
+          },
+          state,
+          scope,
+        );
+
+        if (silentResult) {
+          oidc.tokens = silentResult.tokens;
+          publishEvent(eventNames.token_aquired, {});
+          // @ts-ignore
+          oidc.timeoutId = autoRenewTokens(oidc, oidc.tokens.expiresAt, extras);
+          return {};
         }
+      } catch (e) {
+        return e;
+      }
     };
     return loginLocalAsync();
-};
+  };
 
 export default defaultSilentLoginAsync;

package/src/timer.ts

@@ -1,14 +1,13 @@
 const timer = (function () {
-    // 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),
-    };
-  
-}());
+  // 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),
+  };
+})();
 
 export default timer;

package/src/types.ts

@@ -2,65 +2,75 @@ export type Fetch = typeof window.fetch;
 
 export type LogoutToken = 'access_token' | 'refresh_token';
 
-export type ServiceWorkerUpdateRequireCallback = (registration:any, stopKeepAlive:Function) => Promise<void>;
-export type ServiceWorkerRegister = (serviceWorkerRelativeUrl:string) => Promise<ServiceWorkerRegistration>;
+export type ServiceWorkerUpdateRequireCallback = (
+  registration: any,
+  stopKeepAlive: () => void,
+) => Promise<void>;
+export type ServiceWorkerRegister = (
+  serviceWorkerRelativeUrl: string,
+) => Promise<ServiceWorkerRegistration>;
 export type ServiceWorkerActivate = () => boolean;
 
 export enum TokenAutomaticRenewMode {
-    AutomaticBeforeTokenExpiration = 'AutomaticBeforeTokensExpiration',
-    AutomaticOnlyWhenFetchExecuted = 'AutomaticOnlyWhenFetchExecuted'
+  AutomaticBeforeTokenExpiration = 'AutomaticBeforeTokensExpiration',
+  AutomaticOnlyWhenFetchExecuted = 'AutomaticOnlyWhenFetchExecuted',
 }
 
 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_automatic_renew_mode?: TokenAutomaticRenewMode;
-    token_request_timeout?: number;
-    service_worker_relative_url?:string;
-    service_worker_register?:ServiceWorkerRegister;
-    service_worker_keep_alive_path?:string;
-    service_worker_activate?:ServiceWorkerActivate;
-    service_worker_only?:boolean;
-    service_worker_convert_all_requests_to_cors?:boolean;
-    service_worker_update_require_callback?:ServiceWorkerUpdateRequireCallback;
-    extras?:StringMap;
-    token_request_extras?:StringMap;
-    storage?: Storage;
-    monitor_session?: boolean;
-    token_renew_mode?: string;
-    logout_tokens_to_invalidate?:Array<LogoutToken>;
-    demonstrating_proof_of_possession?:boolean;
-    demonstrating_proof_of_possession_configuration?: DemonstratingProofOfPossessionConfiguration;
-    preload_user_info?:boolean;
+  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_automatic_renew_mode?: TokenAutomaticRenewMode;
+  token_request_timeout?: number;
+  service_worker_relative_url?: string;
+  service_worker_register?: ServiceWorkerRegister;
+  service_worker_keep_alive_path?: string;
+  service_worker_activate?: ServiceWorkerActivate;
+  service_worker_only?: boolean;
+  service_worker_convert_all_requests_to_cors?: boolean;
+  service_worker_update_require_callback?: ServiceWorkerUpdateRequireCallback;
+  extras?: StringMap;
+  token_request_extras?: StringMap;
+  storage?: Storage;
+  monitor_session?: boolean;
+  token_renew_mode?: string;
+  logout_tokens_to_invalidate?: Array<LogoutToken>;
+  demonstrating_proof_of_possession?: boolean;
+  demonstrating_proof_of_possession_configuration?: DemonstratingProofOfPossessionConfiguration;
+  preload_user_info?: boolean;
 };
 
 export interface DemonstratingProofOfPossessionConfiguration {
-    generateKeyAlgorithm:  RsaHashedKeyGenParams | EcKeyGenParams,
-    digestAlgorithm: AlgorithmIdentifier,
-    importKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm,
-    signAlgorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams,
-    jwtHeaderAlgorithm: string
+  generateKeyAlgorithm: RsaHashedKeyGenParams | EcKeyGenParams;
+  digestAlgorithm: AlgorithmIdentifier;
+  importKeyAlgorithm:
+    | AlgorithmIdentifier
+    | RsaHashedImportParams
+    | EcKeyImportParams
+    | HmacImportParams
+    | AesKeyAlgorithm;
+  signAlgorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams;
+  jwtHeaderAlgorithm: string;
 }
 
 export interface StringMap {
-    [key: string]: string;
+  [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;
+  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

@@ -1,22 +1,27 @@
-import Oidc from "./oidc";
-import {fetchWithTokens} from "./fetch";
+import { fetchWithTokens } from './fetch';
+import Oidc from './oidc';
 
-export const userInfoAsync = (oidc:Oidc) => async (noCache = false, demonstrating_proof_of_possession=false) => {
+export const userInfoAsync =
+  (oidc: Oidc) =>
+  async (noCache = false, demonstrating_proof_of_possession = false) => {
     if (oidc.userInfo != null && !noCache) {
-        return oidc.userInfo;
+      return oidc.userInfo;
     }
     const configuration = oidc.configuration;
-    const oidcServerConfiguration = await oidc.initAsync(configuration.authority, configuration.authority_configuration);
+    const oidcServerConfiguration = await oidc.initAsync(
+      configuration.authority,
+      configuration.authority_configuration,
+    );
     const url = oidcServerConfiguration.userInfoEndpoint;
     const fetchUserInfo = async () => {
-        const oidcFetch = fetchWithTokens(fetch, oidc, demonstrating_proof_of_possession);
-        const response = await oidcFetch(url);
-        if (response.status !== 200) {
-            return null;
-        }
-        return response.json();
+      const oidcFetch = fetchWithTokens(fetch, oidc, demonstrating_proof_of_possession);
+      const response = await oidcFetch(url);
+      if (response.status !== 200) {
+        return null;
+      }
+      return response.json();
     };
     const userInfo = await fetchUserInfo();
     oidc.userInfo = userInfo;
     return userInfo;
-};
+  };

package/src/version.ts

@@ -1 +1 @@
-export default '7.22.18';
+export default '7.22.19';