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

package/dist/lib/verifier-js.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:
  *
@@ -1537,7 +1537,7 @@ var AbortSessionErrorMessage;
     AbortSessionErrorMessage["FailedToAbortSession"] = "Failed to abort session";
 })(AbortSessionErrorMessage || (AbortSessionErrorMessage = {}));
 
-const InitialiseOptionsValidator = object({
+const InitializeOptionsValidator = object({
     apiBaseUrl: pipe(string(), nonEmpty("Must not be empty")),
     applicationId: pipe(string(), nonEmpty("Must not be empty"))
 });
@@ -1580,20 +1580,20 @@ const safeFetch = async (input, init) => {
     }
 };
 
-let initialiseOptions = undefined;
+let initializeOptions = undefined;
 
-var InitialiseErrorMessage;
+var InitializeErrorMessage;
 
-(function(InitialiseErrorMessage) {
-    InitialiseErrorMessage["SdkNotInitialised"] = "SDK not initialised";
-})(InitialiseErrorMessage || (InitialiseErrorMessage = {}));
+(function(InitializeErrorMessage) {
+    InitializeErrorMessage["SdkNotInitialized"] = "SDK not initialized";
+})(InitializeErrorMessage || (InitializeErrorMessage = {}));
 
-const initialise = options => {
-    assertType(InitialiseOptionsValidator, "Invalid initialise options")(options);
-    initialiseOptions = options;
+const initialize = options => {
+    assertType(InitializeOptionsValidator, "Invalid initialize options")(options);
+    initializeOptions = options;
 };
 
-const getInitialiseOptions = () => initialiseOptions;
+const getInitializeOptions = () => initializeOptions;
 
 let sessionAbortController = undefined;
 
@@ -1601,22 +1601,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;
@@ -1624,9 +1629,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;
 };
 
 var isMobile_1 = isMobile;
@@ -1938,25 +1947,50 @@ const requestCredentialsWithCrossDevice = async options => {
     }));
 };
 
+const abortCredentialRequest = async () => {
+    const initializeOptions = getInitializeOptions();
+    if (!initializeOptions) {
+        throw new Exception(InitializeErrorMessage.SdkNotInitialized);
+    }
+    const {apiBaseUrl: apiBaseUrl} = initializeOptions;
+    const session = getActiveSession();
+    if (!session || !session.sessionKey) {
+        return ok(undefined);
+    }
+    const {sessionId: sessionId, sessionKey: sessionKey} = session;
+    removeActiveSession();
+    const abortSessionResult = await abortSession({
+        apiBaseUrl: apiBaseUrl,
+        sessionId: sessionId,
+        sessionKey: sessionKey
+    });
+    if (abortSessionResult.isErr()) {
+        return err({
+            type: exports.AbortSessionErrorType.AbortSessionFailed,
+            message: AbortSessionErrorMessage.FailedToAbortSession,
+            cause: abortSessionResult.error
+        });
+    }
+    return 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 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 err(parsedCredentialResponseResult.error);
     }
     const parsedCredentialResponse = parsedCredentialResponseResult.value;
@@ -1978,9 +2012,11 @@ const requestCredentialsWithDigitalCredentialsApi = async options => {
     return 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 ok(credentialResponse);
     } catch (exception) {
         return err({
@@ -2130,12 +2166,12 @@ const requestCredentialsSameDevice = async options => {
 
 const requestCredentials = async options => {
     var _a;
-    const initialiseOptions = getInitialiseOptions();
-    if (!initialiseOptions) {
-        throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
+    const initializeOptions = getInitializeOptions();
+    if (!initializeOptions) {
+        throw new Exception(InitializeErrorMessage.SdkNotInitialized);
     }
     assertType(RequestCredentialsOptionsValidator, "Invalid request credential options")(options);
-    const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
+    const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initializeOptions;
     const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration} = options;
     const dcApiSupported = isDigitalCredentialsApiSupported();
     const openId4VpRedirectUri = deriveOpenId4vpRedirectUri(openid4vpConfiguration);
@@ -2158,13 +2194,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) {
@@ -2225,11 +2262,11 @@ var HandleRedirectCallbackErrorMessage;
 })(HandleRedirectCallbackErrorMessage || (HandleRedirectCallbackErrorMessage = {}));
 
 const handleRedirectCallback = async () => {
-    const initialiseOptions = getInitialiseOptions();
-    if (!initialiseOptions) {
-        throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
+    const initializeOptions = getInitializeOptions();
+    if (!initializeOptions) {
+        throw new Exception(InitializeErrorMessage.SdkNotInitialized);
     }
-    const {apiBaseUrl: apiBaseUrl} = initialiseOptions;
+    const {apiBaseUrl: apiBaseUrl} = initializeOptions;
     const responseCode = getHashParamValue(window.location.hash, "response_code");
     if (!responseCode) {
         return err({
@@ -2264,33 +2301,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 ok(undefined);
-    }
-    const {sessionId: sessionId, sessionKey: sessionKey} = session;
-    removeActiveSession();
-    const abortSessionResult = await abortSession({
-        apiBaseUrl: apiBaseUrl,
-        sessionId: sessionId,
-        sessionKey: sessionKey
-    });
-    if (abortSessionResult.isErr()) {
-        return err({
-            type: exports.AbortSessionErrorType.AbortSessionFailed,
-            message: AbortSessionErrorMessage.FailedToAbortSession,
-            cause: abortSessionResult.error
-        });
-    }
-    return ok(undefined);
-};
-
 const utils = {
     generateChallenge: generateChallenge,
     getVersion: getVersion,
@@ -2301,7 +2311,7 @@ exports.abortCredentialRequest = abortCredentialRequest;
 
 exports.handleRedirectCallback = handleRedirectCallback;
 
-exports.initialise = initialise;
+exports.initialize = initialize;
 
 exports.isDigitalCredentialsApiSupported = isDigitalCredentialsApiSupported;