@mattrglobal/verifier-sdk-web 2.2.1-unstable.9 → 2.3.0

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

@@ -7,8 +7,8 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2026-06-19
- * Version: 2.2.0
+ * Generated: 2026-08-17
+ * Version: 2.3.0
  * Dependencies:
  *
  * neverthrow -- 4.3.0
@@ -1463,6 +1463,7 @@ const CreateSessionOpenId4vpResponseValidator = object({
     sessionId: string(),
     sessionKey: string(),
     sessionUrl: string(),
+    authRequestUri: string(),
     state: optional(string())
 });
 
@@ -1485,7 +1486,7 @@ var LocalStorageKey;
 
 const MATTR_SDK_VERSION_HEADER = "x-mattr-sdk-version";
 
-const MATTR_SDK_VERSION_VALUE = "2.2.0";
+const MATTR_SDK_VERSION_VALUE = "2.3.0";
 
 var MessageEventDataType;
 
@@ -1493,6 +1494,7 @@ var MessageEventDataType;
     MessageEventDataType["PresentationCompleted"] = "PresentationCompleted";
     MessageEventDataType["PresentationTimeout"] = "PresentationTimeout";
     MessageEventDataType["PresentationAbort"] = "PresentationAbort";
+    MessageEventDataType["PresentationRequestUpdated"] = "PresentationRequestUpdated";
 })(MessageEventDataType || (MessageEventDataType = {}));
 
 const OpenId4vpConfigSameDeviceOptionsValidator = object({
@@ -1525,6 +1527,7 @@ exports.RequestCredentialsErrorType = void 0;
     RequestCredentialsErrorType["RequestCredentialsFailed"] = "RequestCredentialsFailed";
     RequestCredentialsErrorType["Timeout"] = "Timeout";
     RequestCredentialsErrorType["Abort"] = "Abort";
+    RequestCredentialsErrorType["OnPresentationRequestFailed"] = "OnPresentationRequestFailed";
 })(exports.RequestCredentialsErrorType || (exports.RequestCredentialsErrorType = {}));
 
 var RequestCredentialsErrorMessage;
@@ -1540,6 +1543,7 @@ var RequestCredentialsErrorMessage;
     RequestCredentialsErrorMessage["Abort"] = "User aborted the session";
     RequestCredentialsErrorMessage["Timeout"] = "User session timeout";
     RequestCredentialsErrorMessage["StateMismatch"] = "State mismatch between requested session and back-channel result";
+    RequestCredentialsErrorMessage["OnPresentationRequestFailed"] = "The onPresentationRequest hook threw an error or rejected";
 })(RequestCredentialsErrorMessage || (RequestCredentialsErrorMessage = {}));
 
 exports.AbortSessionErrorType = void 0;
@@ -1841,7 +1845,7 @@ const exchangeSessionResult = async ({challenge: challenge, responseCode: respon
         body: JSON.stringify(postData)
     });
     const responseResult = await withRetrySafeFetch(fetchResultFn, {
-        retries: 2,
+        retries: 4,
         retryHttpStatus: 404
     });
     if (responseResult.isErr()) {
@@ -1890,71 +1894,111 @@ const closeCrossDeviceModal = options => {
     removeWindowMessageEventListener();
 };
 
-const receiveMessageHandler = options => async event => {
-    const {onComplete: onComplete, onFailure: onFailure, container: container, sessionId: sessionId, apiBaseUrl: apiBaseUrl, challenge: challenge, state: state} = options;
-    if (event.origin !== apiBaseUrl) {
-        return;
-    }
-    if (event.data.type === MessageEventDataType.PresentationCompleted && event.data.responseCode && event.data.sessionId) {
-        const responseCode = event.data.responseCode;
-        const result = await exchangeSessionResult({
-            challenge: challenge,
-            responseCode: responseCode,
-            sessionId: sessionId,
-            apiBaseUrl: apiBaseUrl
-        });
-        if (result.isErr()) {
+const receiveMessageHandler = options => {
+    let queue = Promise.resolve();
+    const processEvent = async event => {
+        const {onComplete: onComplete, onFailure: onFailure, container: container, sessionId: sessionId, sessionKey: sessionKey, apiBaseUrl: apiBaseUrl, challenge: challenge, state: state, onPresentationRequest: onPresentationRequest, isSettled: isSettled} = options;
+        if (isSettled() || event.origin !== apiBaseUrl) {
+            return;
+        }
+        if (event.data.type === MessageEventDataType.PresentationRequestUpdated && event.data.authRequestUri) {
+            if (onPresentationRequest) {
+                try {
+                    await onPresentationRequest({
+                        type: SessionType.Openid4vp,
+                        sessionId: sessionId,
+                        authRequestUri: event.data.authRequestUri
+                    });
+                } catch (cause) {
+                    if (isSettled()) {
+                        return;
+                    }
+                    onFailure({
+                        type: exports.RequestCredentialsErrorType.OnPresentationRequestFailed,
+                        message: RequestCredentialsErrorMessage.OnPresentationRequestFailed,
+                        cause: cause
+                    });
+                    closeCrossDeviceModal({
+                        container: container
+                    });
+                    await abortSession({
+                        apiBaseUrl: apiBaseUrl,
+                        sessionId: sessionId,
+                        sessionKey: sessionKey
+                    });
+                }
+            }
+            return;
+        }
+        if (event.data.type === MessageEventDataType.PresentationCompleted && event.data.responseCode && event.data.sessionId) {
+            const responseCode = event.data.responseCode;
+            const result = await exchangeSessionResult({
+                challenge: challenge,
+                responseCode: responseCode,
+                sessionId: sessionId,
+                apiBaseUrl: apiBaseUrl
+            });
+            if (isSettled()) {
+                return;
+            }
+            if (result.isErr()) {
+                onFailure({
+                    type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                    message: RequestCredentialsErrorMessage.FailedToGetSessionResult
+                });
+                closeCrossDeviceModal({
+                    container: container
+                });
+                return;
+            }
+            const resultState = "challenge" in result.value ? result.value.state : undefined;
+            if (state !== undefined && resultState !== undefined && state !== resultState) {
+                onFailure({
+                    type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                    message: RequestCredentialsErrorMessage.StateMismatch
+                });
+                closeCrossDeviceModal({
+                    container: container
+                });
+                return;
+            }
+            onComplete({
+                result: "challenge" in result.value ? result.value : undefined,
+                sessionId: result.value.sessionId,
+                sessionCompletedInRedirect: false,
+                state: resultState !== null && resultState !== void 0 ? resultState : state
+            });
+            closeCrossDeviceModal({
+                container: container
+            });
+            return;
+        }
+        if (event.data.type === MessageEventDataType.PresentationTimeout) {
             onFailure({
-                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: RequestCredentialsErrorMessage.FailedToGetSessionResult
+                type: exports.RequestCredentialsErrorType.Timeout,
+                message: RequestCredentialsErrorMessage.Timeout
             });
             closeCrossDeviceModal({
                 container: container
             });
             return;
         }
-        const resultState = "challenge" in result.value ? result.value.state : undefined;
-        if (state !== undefined && resultState !== undefined && state !== resultState) {
+        if (event.data.type === MessageEventDataType.PresentationAbort) {
             onFailure({
-                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: RequestCredentialsErrorMessage.StateMismatch
+                type: exports.RequestCredentialsErrorType.Abort,
+                message: RequestCredentialsErrorMessage.Abort
             });
             closeCrossDeviceModal({
                 container: container
             });
             return;
         }
-        onComplete({
-            result: "challenge" in result.value ? result.value : undefined,
-            sessionId: result.value.sessionId,
-            sessionCompletedInRedirect: false,
-            state: resultState !== null && resultState !== void 0 ? resultState : state
-        });
-        closeCrossDeviceModal({
-            container: container
-        });
-        return;
-    }
-    if (event.data.type === MessageEventDataType.PresentationTimeout) {
-        onFailure({
-            type: exports.RequestCredentialsErrorType.Timeout,
-            message: RequestCredentialsErrorMessage.Timeout
-        });
-        closeCrossDeviceModal({
-            container: container
-        });
-        return;
-    }
-    if (event.data.type === MessageEventDataType.PresentationAbort) {
-        onFailure({
-            type: exports.RequestCredentialsErrorType.Abort,
-            message: RequestCredentialsErrorMessage.Abort
-        });
-        closeCrossDeviceModal({
-            container: container
-        });
-        return;
-    }
+    };
+    return event => {
+        const next = queue.then((() => processEvent(event)));
+        queue = next.catch((() => undefined));
+        return next;
+    };
 };
 
 const openCrossDeviceModal = options => {
@@ -1974,16 +2018,18 @@ const openCrossDeviceModal = options => {
 };
 
 const requestCredentialsWithCrossDevice = async options => {
-    const {challenge: challenge, apiBaseUrl: apiBaseUrl, sessionUrl: sessionUrl, sessionId: sessionId, sessionKey: sessionKey, state: state} = options;
+    const {challenge: challenge, apiBaseUrl: apiBaseUrl, sessionUrl: sessionUrl, sessionId: sessionId, sessionKey: sessionKey, state: state, onPresentationRequest: onPresentationRequest} = options;
     const container = openCrossDeviceModal({
         sessionUrl: sessionUrl
     });
+    let settled = false;
     return await new Promise((resolve => {
         const abortController = setActiveSession({
             sessionId: sessionId,
             sessionKey: sessionKey
         });
         abortController.signal.addEventListener("abort", (() => {
+            settled = true;
             closeCrossDeviceModal({
                 container: container
             });
@@ -1996,11 +2042,20 @@ const requestCredentialsWithCrossDevice = async options => {
         listener = receiveMessageHandler({
             container: container,
             sessionId: sessionId,
+            sessionKey: sessionKey,
             apiBaseUrl: apiBaseUrl,
             challenge: challenge,
             state: state,
-            onComplete: data => resolve(ok(data)),
-            onFailure: error => resolve(err(error))
+            onPresentationRequest: onPresentationRequest,
+            isSettled: () => settled,
+            onComplete: data => {
+                settled = true;
+                resolve(ok(data));
+            },
+            onFailure: error => {
+                settled = true;
+                resolve(err(error));
+            }
         });
         window.addEventListener(WindowEventListenerType.message, listener, false);
     }));
@@ -2248,7 +2303,7 @@ const requestCredentials = async options => {
     }
     assertType(RequestCredentialsOptionsValidator, "Invalid request credential options")(options);
     const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initializeOptions;
-    const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration, state: state} = options;
+    const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration, state: state, onPresentationRequest: onPresentationRequest} = options;
     const dcApiSupported = isDigitalCredentialsApiSupported();
     const openId4VpRedirectUri = deriveOpenId4vpRedirectUri(openid4vpConfiguration);
     const createSessionResult = await createSession({
@@ -2270,6 +2325,30 @@ const requestCredentials = async options => {
     }
     const session = createSessionResult.value;
     const {sessionKey: sessionKey, sessionId: sessionId} = session;
+    if (onPresentationRequest) {
+        const presentationRequest = session.type === SessionType.DigitalCredentialsApi ? {
+            type: SessionType.DigitalCredentialsApi,
+            sessionId: sessionId
+        } : {
+            type: SessionType.Openid4vp,
+            sessionId: sessionId,
+            authRequestUri: session.authRequestUri
+        };
+        try {
+            await onPresentationRequest(presentationRequest);
+        } catch (cause) {
+            await abortSession({
+                apiBaseUrl: apiBaseUrl,
+                sessionId: sessionId,
+                sessionKey: sessionKey
+            });
+            return err({
+                type: exports.RequestCredentialsErrorType.OnPresentationRequestFailed,
+                message: RequestCredentialsErrorMessage.OnPresentationRequestFailed,
+                cause: cause
+            });
+        }
+    }
     if (session.type === SessionType.DigitalCredentialsApi) {
         const {request: request, sessionTtl: sessionTtl} = session;
         return await requestCredentialsWithDigitalCredentialsApi({
@@ -2305,7 +2384,8 @@ const requestCredentials = async options => {
         sessionUrl: sessionUrl,
         sessionKey: sessionKey,
         sessionId: sessionId,
-        state: state
+        state: state,
+        onPresentationRequest: onPresentationRequest
     });
 };