@mattrglobal/verifier-sdk-web 1.1.1-unstable.153 → 1.1.1-unstable.154

package/dist/lib/verifier-js-no-deps.cjs.js

@@ -7,7 +7,7 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2025-05-16
+ * Generated: 2025-05-18
  * Version: 1.1.0
  * Dependencies:
  */
@@ -371,22 +371,27 @@ let _sessionId = undefined;
 
 let _sessionKey = undefined;
 
+let _sessionTimeoutId = undefined;
+
 const getActiveSession = () => {
     const sessionId = _sessionId;
     const sessionKey = _sessionKey;
+    const sessionTimeoutId = _sessionTimeoutId;
     if (sessionId) {
         return {
             sessionId: sessionId,
-            sessionKey: sessionKey
+            sessionKey: sessionKey,
+            sessionTimeoutId: sessionTimeoutId
         };
     }
     return undefined;
 };
 
 const setActiveSession = session => {
-    const {sessionId: sessionId, sessionKey: sessionKey} = session;
+    const {sessionId: sessionId, sessionKey: sessionKey, sessionTimeoutId: sessionTimeoutId} = session;
     _sessionId = sessionId;
     _sessionKey = sessionKey;
+    _sessionTimeoutId = sessionTimeoutId;
     const abortController = new AbortController;
     sessionAbortController = abortController;
     return abortController;
@@ -394,9 +399,13 @@ const setActiveSession = session => {
 
 const removeActiveSession = () => {
     sessionAbortController === null || sessionAbortController === void 0 ? void 0 : sessionAbortController.abort();
+    if (_sessionTimeoutId) {
+        window.clearTimeout(_sessionTimeoutId);
+    }
     sessionAbortController = undefined;
     _sessionKey = undefined;
     _sessionId = undefined;
+    _sessionTimeoutId = undefined;
 };
 
 const defaultRetryDelay = attempt => Math.pow(2, attempt) * 1e3;
@@ -677,25 +686,50 @@ const requestCredentialsWithCrossDevice = async options => {
     }));
 };
 
+const abortCredentialRequest = async () => {
+    const initialiseOptions = getInitialiseOptions();
+    if (!initialiseOptions) {
+        throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
+    }
+    const {apiBaseUrl: apiBaseUrl} = initialiseOptions;
+    const session = getActiveSession();
+    if (!session || !session.sessionKey) {
+        return neverthrow.ok(undefined);
+    }
+    const {sessionId: sessionId, sessionKey: sessionKey} = session;
+    removeActiveSession();
+    const abortSessionResult = await abortSession({
+        apiBaseUrl: apiBaseUrl,
+        sessionId: sessionId,
+        sessionKey: sessionKey
+    });
+    if (abortSessionResult.isErr()) {
+        return neverthrow.err({
+            type: exports.AbortSessionErrorType.AbortSessionFailed,
+            message: AbortSessionErrorMessage.FailedToAbortSession,
+            cause: abortSessionResult.error
+        });
+    }
+    return neverthrow.ok(undefined);
+};
+
 const requestCredentialsWithDigitalCredentialsApi = async options => {
-    const {apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey, challenge: challenge, request: request} = options;
-    const credentialResponseResult = await getCredentials(request);
+    const {apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey, challenge: challenge, request: request, sessionTtl: sessionTtl} = options;
+    const sessionTimeoutId = window.setTimeout((() => removeActiveSession()), sessionTtl * 1e3);
+    const abortController = setActiveSession({
+        sessionId: sessionId,
+        sessionKey: sessionKey,
+        sessionTimeoutId: sessionTimeoutId
+    });
+    const credentialResponseResult = await getCredentials(request, abortController);
     if (credentialResponseResult.isErr()) {
-        await abortSession({
-            apiBaseUrl: apiBaseUrl,
-            sessionId: sessionId,
-            sessionKey: sessionKey
-        });
+        await abortCredentialRequest();
         return neverthrow.err(credentialResponseResult.error);
     }
     const credentialResponse = credentialResponseResult.value;
     const parsedCredentialResponseResult = parseCredentialResponse(credentialResponse);
     if (parsedCredentialResponseResult.isErr()) {
-        await abortSession({
-            apiBaseUrl: apiBaseUrl,
-            sessionId: sessionId,
-            sessionKey: sessionKey
-        });
+        await abortCredentialRequest();
         return neverthrow.err(parsedCredentialResponseResult.error);
     }
     const parsedCredentialResponse = parsedCredentialResponseResult.value;
@@ -717,9 +751,11 @@ const requestCredentialsWithDigitalCredentialsApi = async options => {
     return neverthrow.ok(credentialVerificationResult.value);
 };
 
-const getCredentials = async request => {
+const getCredentials = async (request, abortController) => {
     try {
-        const credentialResponse = await navigator.credentials.get(request);
+        const credentialResponse = await navigator.credentials.get(Object.assign(Object.assign({}, request), {
+            signal: abortController.signal
+        }));
         return neverthrow.ok(credentialResponse);
     } catch (exception) {
         return neverthrow.err({
@@ -897,13 +933,14 @@ const requestCredentials = async options => {
     const session = createSessionResult.value;
     const {sessionKey: sessionKey, sessionId: sessionId} = session;
     if (session.type === SessionType.DigitalCredentialsApi) {
-        const {request: request} = session;
+        const {request: request, sessionTtl: sessionTtl} = session;
         return await requestCredentialsWithDigitalCredentialsApi({
             apiBaseUrl: apiBaseUrl,
             request: request,
             sessionId: sessionId,
             sessionKey: sessionKey,
-            challenge: challenge
+            challenge: challenge,
+            sessionTtl: sessionTtl
         });
     }
     if (!openid4vpConfiguration) {
@@ -1003,33 +1040,6 @@ const handleRedirectCallback = async () => {
     });
 };
 
-const abortCredentialRequest = async () => {
-    const initialiseOptions = getInitialiseOptions();
-    if (!initialiseOptions) {
-        throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
-    }
-    const {apiBaseUrl: apiBaseUrl} = initialiseOptions;
-    const session = getActiveSession();
-    if (!session || !session.sessionKey) {
-        return neverthrow.ok(undefined);
-    }
-    const {sessionId: sessionId, sessionKey: sessionKey} = session;
-    removeActiveSession();
-    const abortSessionResult = await abortSession({
-        apiBaseUrl: apiBaseUrl,
-        sessionId: sessionId,
-        sessionKey: sessionKey
-    });
-    if (abortSessionResult.isErr()) {
-        return neverthrow.err({
-            type: exports.AbortSessionErrorType.AbortSessionFailed,
-            message: AbortSessionErrorMessage.FailedToAbortSession,
-            cause: abortSessionResult.error
-        });
-    }
-    return neverthrow.ok(undefined);
-};
-
 const utils = {
     generateChallenge: generateChallenge,
     getVersion: getVersion,