@axa-fr/oidc-client 7.22.18 → 7.22.19

package/src/cache.ts

@@ -1,26 +1,29 @@
 const fetchFromIssuerCache = {};
 
 export const getFromCache = (localStorageKey, storage = window.sessionStorage, timeCacheSecond) => {
-    if (!fetchFromIssuerCache[localStorageKey]) {
-        if (storage) {
-            const cacheJson = storage.getItem(localStorageKey);
-            if (cacheJson) {
-                fetchFromIssuerCache[localStorageKey] = JSON.parse(cacheJson);
-            }
-        }
-    }
-    const oneHourMinisecond = 1000 * timeCacheSecond;
-    // @ts-ignore
-    if (fetchFromIssuerCache[localStorageKey] && (fetchFromIssuerCache[localStorageKey].timestamp + oneHourMinisecond) > Date.now()) {
-        return fetchFromIssuerCache[localStorageKey].result;
+  if (!fetchFromIssuerCache[localStorageKey]) {
+    if (storage) {
+      const cacheJson = storage.getItem(localStorageKey);
+      if (cacheJson) {
+        fetchFromIssuerCache[localStorageKey] = JSON.parse(cacheJson);
+      }
     }
-    return null;
+  }
+  const oneHourMinisecond = 1000 * timeCacheSecond;
+  // @ts-ignore
+  if (
+    fetchFromIssuerCache[localStorageKey] &&
+    fetchFromIssuerCache[localStorageKey].timestamp + oneHourMinisecond > Date.now()
+  ) {
+    return fetchFromIssuerCache[localStorageKey].result;
+  }
+  return null;
 };
 
 export const setCache = (localStorageKey, result, storage = window.sessionStorage) => {
-    const timestamp = Date.now();
-    fetchFromIssuerCache[localStorageKey] = { result, timestamp };
-    if (storage) {
-        storage.setItem(localStorageKey, JSON.stringify({ result, timestamp }));
-    }
+  const timestamp = Date.now();
+  fetchFromIssuerCache[localStorageKey] = { result, timestamp };
+  if (storage) {
+    storage.setItem(localStorageKey, JSON.stringify({ result, timestamp }));
+  }
 };

package/src/checkSession.ts

@@ -1,64 +1,99 @@
 import { CheckSessionIFrame } from './checkSessionIFrame.js';
+import Oidc from './oidc';
 import { _silentLoginAsync, SilentLoginResponse } from './silentLogin.js';
 import { OidcConfiguration } from './types.js';
-import Oidc from "./oidc";
 
-// eslint-disable-next-line @typescript-eslint/ban-types
-export const startCheckSessionAsync = (oidc:Oidc, oidcDatabase:any, configuration :OidcConfiguration) => (checkSessionIFrameUri, clientId, sessionState, isSilentSignin = false) => {
-    const silentLoginAsync = (extras, state = undefined, scope = undefined):Promise<SilentLoginResponse> => {
-        return _silentLoginAsync(oidc.configurationName, configuration, oidc.publishEvent.bind(oidc))(extras, state, scope);
+export const startCheckSessionAsync =
+  (oidc: Oidc, oidcDatabase: any, configuration: OidcConfiguration) =>
+  (checkSessionIFrameUri, clientId, sessionState, isSilentSignin = false) => {
+    const silentLoginAsync = (
+      extras,
+      state = undefined,
+      scope = undefined,
+    ): Promise<SilentLoginResponse> => {
+      return _silentLoginAsync(oidc.configurationName, configuration, oidc.publishEvent.bind(oidc))(
+        extras,
+        state,
+        scope,
+      );
     };
 
     return new Promise<CheckSessionIFrame>((resolve, reject): void => {
-        if (configuration.silent_login_uri && configuration.silent_redirect_uri && configuration.monitor_session && checkSessionIFrameUri && sessionState && !isSilentSignin) {
-            const checkSessionCallback = () => {
-                oidc.checkSessionIFrame.stop();
-                const tokens = oidc.tokens;
-                if (tokens === null) {
-                    return;
+      if (
+        configuration.silent_login_uri &&
+        configuration.silent_redirect_uri &&
+        configuration.monitor_session &&
+        checkSessionIFrameUri &&
+        sessionState &&
+        !isSilentSignin
+      ) {
+        const checkSessionCallback = () => {
+          oidc.checkSessionIFrame.stop();
+          const tokens = oidc.tokens;
+          if (tokens === null) {
+            return;
+          }
+          const idToken = tokens.idToken;
+          const idTokenPayload = tokens.idTokenPayload;
+          return silentLoginAsync({
+            prompt: 'none',
+            id_token_hint: idToken,
+            scope: configuration.scope || 'openid',
+          })
+            .then(silentSigninResponse => {
+              if (silentSigninResponse.error) {
+                throw new Error(silentSigninResponse.error);
+              }
+              const iFrameIdTokenPayload = silentSigninResponse.tokens.idTokenPayload;
+              if (idTokenPayload.sub === iFrameIdTokenPayload.sub) {
+                const sessionState = silentSigninResponse.sessionState;
+                oidc.checkSessionIFrame.start(silentSigninResponse.sessionState);
+                if (idTokenPayload.sid === iFrameIdTokenPayload.sid) {
+                  console.debug(
+                    'SessionMonitor._callback: Same sub still logged in at OP, restarting check session iframe; session_state:',
+                    sessionState,
+                  );
+                } else {
+                  console.debug(
+                    'SessionMonitor._callback: Same sub still logged in at OP, session state has changed, restarting check session iframe; session_state:',
+                    sessionState,
+                  );
                 }
-                const idToken = tokens.idToken;
-                const idTokenPayload = tokens.idTokenPayload;
-                return silentLoginAsync({
-                    prompt: 'none',
-                    id_token_hint: idToken,
-                    scope: configuration.scope || 'openid',
-                }).then((silentSigninResponse) => {
-                    if(silentSigninResponse.error) {
-                        throw new Error(silentSigninResponse.error);
-                    }   
-                    const iFrameIdTokenPayload = silentSigninResponse.tokens.idTokenPayload;
-                    if (idTokenPayload.sub === iFrameIdTokenPayload.sub) {
-                        const sessionState = silentSigninResponse.sessionState;
-                        oidc.checkSessionIFrame.start(silentSigninResponse.sessionState);
-                        if (idTokenPayload.sid === iFrameIdTokenPayload.sid) {
-                            console.debug('SessionMonitor._callback: Same sub still logged in at OP, restarting check session iframe; session_state:', sessionState);
-                        } else {
-                            console.debug('SessionMonitor._callback: Same sub still logged in at OP, session state has changed, restarting check session iframe; session_state:', sessionState);
-                        }
-                    } else {
-                        console.debug('SessionMonitor._callback: Different subject signed into OP:', iFrameIdTokenPayload.sub);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                }).catch(async (e) => {
-                    console.warn('SessionMonitor._callback: Silent login failed, logging out other tabs:', e);
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    for (const [key, oidc] of Object.entries(oidcDatabase)) {
-                        // @ts-ignore
-                        await oidc.logoutOtherTabAsync(configuration.client_id, idTokenPayload.sub);
-                    }
-                });
-            };
-
-            oidc.checkSessionIFrame = new CheckSessionIFrame(checkSessionCallback, clientId, checkSessionIFrameUri);
-            oidc.checkSessionIFrame.load().then(() => {
-                oidc.checkSessionIFrame.start(sessionState);
-                resolve(oidc.checkSessionIFrame);
-            }).catch((e) => {
-                reject(e);
+              } else {
+                console.debug(
+                  'SessionMonitor._callback: Different subject signed into OP:',
+                  iFrameIdTokenPayload.sub,
+                );
+              }
+            })
+            .catch(async e => {
+              console.warn(
+                'SessionMonitor._callback: Silent login failed, logging out other tabs:',
+                e,
+              );
+              for (const [, oidc] of Object.entries(oidcDatabase)) {
+                // @ts-ignore
+                await oidc.logoutOtherTabAsync(configuration.client_id, idTokenPayload.sub);
+              }
             });
-        } else {
-            resolve(null);
-        }
+        };
+
+        oidc.checkSessionIFrame = new CheckSessionIFrame(
+          checkSessionCallback,
+          clientId,
+          checkSessionIFrameUri,
+        );
+        oidc.checkSessionIFrame
+          .load()
+          .then(() => {
+            oidc.checkSessionIFrame.start(sessionState);
+            resolve(oidc.checkSessionIFrame);
+          })
+          .catch(e => {
+            reject(e);
+          });
+      } else {
+        resolve(null);
+      }
     });
-};
+  };

package/src/checkSessionIFrame.ts

@@ -3,81 +3,82 @@ const DefaultInterval = 2000;
 const Log = console;
 
 export class CheckSessionIFrame {
-    private readonly _client_id: any;
-    private readonly _callback: any;
-    private _url: any;
-    private readonly _interval: number;
-    private readonly _stopOnError: boolean;
-    private readonly _frame_origin: string;
-    private readonly _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;
+  private readonly _client_id: any;
+  private readonly _callback: any;
+  private _url: any;
+  private readonly _interval: number;
+  private readonly _stopOnError: boolean;
+  private readonly _frame_origin: string;
+  private readonly _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.substring(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;
-    }
+    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);
-        });
-    }
+  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') {
-                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');
-                this.stop();
-                this._callback();
-            } else {
-                Log.debug('CheckSessionIFrame: ' + e.data + ' message from check session op iframe');
-            }
+  _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 (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();
-            const send = () => {
-                this._frame.contentWindow.postMessage(this._client_id + ' ' + session_state, this._frame_origin);
-            };
-            send();
-            this._timer = window.setInterval(send, this._interval);
-    }
+  start(session_state) {
+    Log.debug('CheckSessionIFrame.start :' + session_state);
+    this.stop();
+    const 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;
-        }
+  stop() {
+    if (this._timer) {
+      Log.debug('CheckSessionIFrame.stop');
+      window.clearInterval(this._timer);
+      this._timer = null;
     }
+  }
 }

package/src/crypto.ts

@@ -1,5 +1,4 @@
-import {uint8ToUrlBase64} from "./jwt";
-
+import { uint8ToUrlBase64 } from './jwt';
 
 const cryptoInfo = () => {
   const hasCrypto = typeof window !== 'undefined' && !!(window.crypto as any);
@@ -18,18 +17,18 @@ const bufferToString = (buffer: Uint8Array) => {
 };
 
 export const generateRandom = (size: number) => {
-    const buffer = new Uint8Array(size);
-    const { hasCrypto } = cryptoInfo();
-    if (hasCrypto) {
-      window.crypto.getRandomValues(buffer);
-    } else {
-      // fall back to Math.random() if nothing else is available
-      for (let i = 0; i < size; i += 1) {
-        buffer[i] = (Math.random() * charset.length) | 0;
-      }
+  const buffer = new Uint8Array(size);
+  const { hasCrypto } = cryptoInfo();
+  if (hasCrypto) {
+    window.crypto.getRandomValues(buffer);
+  } else {
+    // fall back to Math.random() if nothing else is available
+    for (let i = 0; i < size; i += 1) {
+      buffer[i] = (Math.random() * charset.length) | 0;
     }
-    return bufferToString(buffer);
-  };
+  }
+  return bufferToString(buffer);
+};
 
 export function textEncodeLite(str: string) {
   const buf = new ArrayBuffer(str.length);
@@ -41,22 +40,25 @@ export function textEncodeLite(str: string) {
   return bufView;
 }
 
-export function base64urlOfHashOfASCIIEncodingAsync(code: string):Promise<string> {
+export function base64urlOfHashOfASCIIEncodingAsync(code: string): Promise<string> {
   return new Promise((resolve, reject) => {
-    crypto.subtle.digest('SHA-256', textEncodeLite(code)).then(buffer => {
-      return resolve(uint8ToUrlBase64(new Uint8Array(buffer)));
-    }, error => reject(error));
+    crypto.subtle.digest('SHA-256', textEncodeLite(code)).then(
+      buffer => {
+        return resolve(uint8ToUrlBase64(new Uint8Array(buffer)));
+      },
+      error => reject(error),
+    );
   });
 }
 
 export const deriveChallengeAsync = (code: string): Promise<string> => {
-    if (code.length < 43 || code.length > 128) {
-      return Promise.reject(new Error('Invalid code length.'));
-    }
-    const { hasSubtleCrypto } = cryptoInfo();
-    if (!hasSubtleCrypto) {
-      return Promise.reject(new Error('window.crypto.subtle is unavailable.'));
-    }
+  if (code.length < 43 || code.length > 128) {
+    return Promise.reject(new Error('Invalid code length.'));
+  }
+  const { hasSubtleCrypto } = cryptoInfo();
+  if (!hasSubtleCrypto) {
+    return Promise.reject(new Error('window.crypto.subtle is unavailable.'));
+  }
 
-    return base64urlOfHashOfASCIIEncodingAsync(code);
+  return base64urlOfHashOfASCIIEncodingAsync(code);
 };

package/src/events.ts

@@ -1,30 +1,30 @@
 export const eventNames = {
-    service_worker_not_supported_by_browser: 'service_worker_not_supported_by_browser',
-    token_aquired: 'token_aquired',
-    logout_from_another_tab: 'logout_from_another_tab',
-    logout_from_same_tab: 'logout_from_same_tab',
-    token_renewed: 'token_renewed',
-    token_timer: 'token_timer',
-    loginAsync_begin: 'loginAsync_begin',
-    loginAsync_error: 'loginAsync_error',
-    loginCallbackAsync_begin: 'loginCallbackAsync_begin',
-    loginCallbackAsync_end: 'loginCallbackAsync_end',
-    loginCallbackAsync_error: 'loginCallbackAsync_error',
-    refreshTokensAsync_begin: 'refreshTokensAsync_begin',
-    refreshTokensAsync: 'refreshTokensAsync',
-    refreshTokensAsync_end: 'refreshTokensAsync_end',
-    refreshTokensAsync_error: 'refreshTokensAsync_error',
-    refreshTokensAsync_silent_error: 'refreshTokensAsync_silent_error',
-    tryKeepExistingSessionAsync_begin: 'tryKeepExistingSessionAsync_begin',
-    tryKeepExistingSessionAsync_end: 'tryKeepExistingSessionAsync_end',
-    tryKeepExistingSessionAsync_error: 'tryKeepExistingSessionAsync_error',
-    silentLoginAsync_begin: 'silentLoginAsync_begin',
-    silentLoginAsync: 'silentLoginAsync',
-    silentLoginAsync_end: 'silentLoginAsync_end',
-    silentLoginAsync_error: 'silentLoginAsync_error',
-    syncTokensAsync_begin: 'syncTokensAsync_begin',
-    syncTokensAsync_lock_not_available: 'syncTokensAsync_lock_not_available',
-    syncTokensAsync_end: 'syncTokensAsync_end',
-    syncTokensAsync_error: 'syncTokensAsync_error',
-    tokensInvalidAndWaitingActionsToRefresh: 'tokensInvalidAndWaitingActionsToRefresh',
+  service_worker_not_supported_by_browser: 'service_worker_not_supported_by_browser',
+  token_aquired: 'token_aquired',
+  logout_from_another_tab: 'logout_from_another_tab',
+  logout_from_same_tab: 'logout_from_same_tab',
+  token_renewed: 'token_renewed',
+  token_timer: 'token_timer',
+  loginAsync_begin: 'loginAsync_begin',
+  loginAsync_error: 'loginAsync_error',
+  loginCallbackAsync_begin: 'loginCallbackAsync_begin',
+  loginCallbackAsync_end: 'loginCallbackAsync_end',
+  loginCallbackAsync_error: 'loginCallbackAsync_error',
+  refreshTokensAsync_begin: 'refreshTokensAsync_begin',
+  refreshTokensAsync: 'refreshTokensAsync',
+  refreshTokensAsync_end: 'refreshTokensAsync_end',
+  refreshTokensAsync_error: 'refreshTokensAsync_error',
+  refreshTokensAsync_silent_error: 'refreshTokensAsync_silent_error',
+  tryKeepExistingSessionAsync_begin: 'tryKeepExistingSessionAsync_begin',
+  tryKeepExistingSessionAsync_end: 'tryKeepExistingSessionAsync_end',
+  tryKeepExistingSessionAsync_error: 'tryKeepExistingSessionAsync_error',
+  silentLoginAsync_begin: 'silentLoginAsync_begin',
+  silentLoginAsync: 'silentLoginAsync',
+  silentLoginAsync_end: 'silentLoginAsync_end',
+  silentLoginAsync_error: 'silentLoginAsync_error',
+  syncTokensAsync_begin: 'syncTokensAsync_begin',
+  syncTokensAsync_lock_not_available: 'syncTokensAsync_lock_not_available',
+  syncTokensAsync_end: 'syncTokensAsync_end',
+  syncTokensAsync_error: 'syncTokensAsync_error',
+  tokensInvalidAndWaitingActionsToRefresh: 'tokensInvalidAndWaitingActionsToRefresh',
 };

package/src/fetch.ts

@@ -1,37 +1,56 @@
-import {Fetch} from "./types";
-import {OidcClient} from "./oidcClient";
-import {getValidTokenAsync} from "./parseTokens";
+import Oidc from './oidc';
+import {getValidTokenAsync, OidcToken, Tokens} from './parseTokens';
+import {Fetch, StringMap, TokenAutomaticRenewMode} from './types';
 
 // @ts-ignore
-export const fetchWithTokens = (fetch: Fetch, oidcClient: Oidc | null, demonstrating_proof_of_possession:boolean=false) : Fetch => async (...params: Parameters<Fetch>) :Promise<Response> => {
+export const fetchWithTokens =
+  (
+    fetch: Fetch,
+    oidc: Oidc | null,
+    demonstrating_proof_of_possession: boolean = false,
+  ): Fetch =>
+  async (...params: Parameters<Fetch>): Promise<Response> => {
     const [url, options, ...rest] = params;
     const optionTmp = options ? { ...options } : { method: 'GET' };
     let headers = new Headers();
     if (optionTmp.headers) {
-        headers = !(optionTmp.headers instanceof Headers)
-            ? new Headers(optionTmp.headers)
-            : optionTmp.headers;
+      headers = !(optionTmp.headers instanceof Headers)
+        ? new Headers(optionTmp.headers)
+        : optionTmp.headers;
+    }
+    
+    const oidcToken : OidcToken = {
+      tokens: oidc.tokens,
+      configuration: { token_automatic_renew_mode: oidc.configuration.token_automatic_renew_mode },
+      renewTokensAsync: oidc.renewTokensAsync.bind(oidc),
     }
-    const oidc = oidcClient;
 
     // @ts-ignore
-    const getValidToken = await getValidTokenAsync(oidc);
+    const getValidToken = await getValidTokenAsync(oidcToken);
     const accessToken = getValidToken?.tokens?.accessToken;
     if (!headers.has('Accept')) {
-        headers.set('Accept', 'application/json');
+      headers.set('Accept', 'application/json');
     }
     if (accessToken) {
-        if(oidc.configuration.demonstrating_proof_of_possession && demonstrating_proof_of_possession) {
-            const demonstrationOdProofOfPossession = await oidc.generateDemonstrationOfProofOfPossessionAsync(accessToken, url.toString(), optionTmp.method);
-            headers.set('Authorization', `PoP ${accessToken}`);
-            headers.set('DPoP', demonstrationOdProofOfPossession);
-        } else {
-            headers.set('Authorization', `Bearer ${accessToken}`);
-        }
-        if (!optionTmp.credentials) {
-            optionTmp.credentials = 'same-origin';
-        }
+      if (
+        oidc.configuration.demonstrating_proof_of_possession &&
+        demonstrating_proof_of_possession
+      ) {
+        const demonstrationOdProofOfPossession =
+          await oidc.generateDemonstrationOfProofOfPossessionAsync(
+            accessToken,
+            url.toString(),
+            optionTmp.method,
+          );
+        headers.set('Authorization', `PoP ${accessToken}`);
+        headers.set('DPoP', demonstrationOdProofOfPossession);
+      } else {
+        headers.set('Authorization', `Bearer ${accessToken}`);
+      }
+      if (!optionTmp.credentials) {
+        optionTmp.credentials = 'same-origin';
+      }
     }
     const newOptions = { ...optionTmp, headers };
     return await fetch(url, newOptions, ...rest);
-};
+  };

package/src/index.ts

@@ -1,21 +1,10 @@
-
+export type { ILOidcLocation } from './location.js';
+export { OidcLocation } from './location.js';
 export { getFetchDefault } from './oidc.js';
+export type { OidcUserInfo } from './oidcClient.js';
+export { OidcClient } from './oidcClient.js';
+export type { Tokens } from './parseTokens.js';
 export { TokenRenewMode } from './parseTokens.js';
 export { getParseQueryStringFromLocation, getPath } from './route-utils';
-
-export type {
-  Tokens
-} from './parseTokens.js';
-
-export type {
-  AuthorityConfiguration,
-  Fetch,
-  OidcConfiguration,
-  StringMap
-} from './types.js';
-
-export { OidcLocation } from './location.js';
-export type { ILOidcLocation } from './location.js';
+export type { AuthorityConfiguration, Fetch, OidcConfiguration, StringMap } from './types.js';
 export { TokenAutomaticRenewMode } from './types.js';
-export { OidcClient } from './oidcClient.js';
-export type { OidcUserInfo } from './oidcClient.js';

package/src/iniWorker.spec.ts

@@ -1,21 +1,31 @@
-import { describe, expect,it } from 'vitest';
+import { describe, expect, it } from 'vitest';
 
 import { excludeOs, getOperatingSystem } from './initWorkerOption';
 
 describe('initWorker test Suite', () => {
+  it.each([
+    [
+      'Mozilla/5.0 (iPhone; CPU iPhone OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1',
+      'iOS',
+      '12.1.0',
+    ],
+    [
+      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/69.0.3497.105 Mobile/15E148 Safari/605.1',
+      'Mac OS X',
+      '10_15_6',
+    ],
+  ])(
+    'getOperatingSystem should return OS for Version',
+    (userAgent, expectedOs, expectedVersion) => {
+      const operatingSystem = getOperatingSystem({
+        userAgent,
+        appVersion: 'OS ' + expectedVersion.replaceAll('.', '_'),
+      });
+      expect(expectedOs).toBe(operatingSystem.os);
+      expect(expectedVersion).toBe(operatingSystem.osVersion);
 
-    it.each([['Mozilla/5.0 (iPhone; CPU iPhone OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1', 'iOS', '12.1.0'],
-    ['Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/69.0.3497.105 Mobile/15E148 Safari/605.1', 'Mac OS X', '10_15_6'],
-    ])(
-        'getOperatingSystem should return OS for Version',
-        (userAgent, expectedOs, expectedVersion) => {
-            const operatingSystem = getOperatingSystem({ userAgent, appVersion: 'OS ' + expectedVersion.replaceAll('.', '_') });
-            expect(expectedOs).toBe(operatingSystem.os);
-            expect(expectedVersion).toBe(operatingSystem.osVersion);
-    
-            const isExcluded = excludeOs(operatingSystem);
-            expect(isExcluded).toBe(true);
-        },
-    );
-
-});
+      const isExcluded = excludeOs(operatingSystem);
+      expect(isExcluded).toBe(true);
+    },
+  );
+});