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

package/README.md

@@ -12,7 +12,7 @@
     - [Web project with an existing bundler set up](#web-project-with-an-existing-bundler-set-up)
     - [Loading directly from script tag](#loading-directly-from-script-tag)
 - [Usage](#usage)
-  - [Initialise the SDK](#initialise-the-sdk)
+  - [Initialize the SDK](#initialize-the-sdk)
   - [Prepare a credential query](#prepare-a-credential-query)
   - [Generate challenge](#generate-challenge)
   - [Determine supported presentation flows](#determine-supported-presentation-flows)
@@ -29,7 +29,7 @@
 ## Licensing
 
 Request or download the
-[MATTR Pi SDK Trial Licence Agreement](https://learn.mattr.global/docs/terms/mattr-pi-sdk-licence-agreement) and the
+[MATTR Pi SDK Trial License Agreement](https://learn.mattr.global/docs/terms/mattr-pi-sdk-licence-agreement) and the
 [MATTR Customer Agreement](https://learn.mattr.global/docs/terms/customer-agreement) and review these terms carefully.
 
 ## Overview
@@ -69,7 +69,7 @@ yarn add @mattrglobal/verifier-sdk-web
 ```javascript
 import * as MATTRVerifierSDK from "@mattrglobal/verifier-sdk-web";
 
-MATTRVerifierSDK.initialise(...);
+MATTRVerifierSDK.initialize(...);
 ```
 
 ### Loading directly from script tag
@@ -86,26 +86,26 @@ MATTRVerifierSDK.initialise(...);
 
 ```javascript
 <script> 
-   MATTRVerifierSDK.initialise(...);
+   MATTRVerifierSDK.initialize(...);
 </script> 
 ```
 
 # Usage
 
 The SDK can make a request to create a presentation session with a configured MATTR VII verifier tenant. This requires the following configurations and settings:
-* Initialise the SDK with the URL of the MATTR VII tenant that will handle the verification request.
+* Initialize the SDK with the URL of the MATTR VII tenant that will handle the verification request.
 * Prepare a credential query that defines what claims are required for verification.
 * Generate a unique challenge for the presentation session.
 * Determine what presentation flows are supported in the session.
 * Define what wallets can be used to respond to the verification request.
 * Configure the URI the user will be redirected to when the verification workflow is completed (only required for same-device flows).
 
-## Initialise the SDK
+## Initialize the SDK
 
-You must initialise the SDK before you can use any of its functions and methods:
+You must initialize the SDK before you can use any of its functions and methods:
 
 ```javascript
-MATTRVerifierSDK.initialise({ apiBaseUrl, applicationId });
+MATTRVerifierSDK.initialize({ apiBaseUrl, applicationId });
 ```
 
 - `apiBaseUrl` (required): URL of the MATTR VII verifier tenant.
@@ -144,7 +144,7 @@ const credentialQuery = [
 ```
 * `profile`: Credential format of the credential that will be verified. Currently only mobile (mDocs) is supported.
 * `docType`: the mDL’s type. Confirm with the certificate issuer for what docType they are issuing. Some common examples include:
-  * Mobile Driver Licence (`org.iso.18013.5.1.mDL`).
+  * Mobile Driver License (`org.iso.18013.5.1.mDL`).
   * PhotoID (`org.iso.23220.photoid.1`).
   * Mobile Vehicle Registration Card (`org.iso.7367.1.mVRC`).
   * Health certificate (`org.micov.vtr.1`).
@@ -197,7 +197,7 @@ When using the same-device presentation flow, the SDK must define what URI to re
 ## Request credentials with automatic flow selection
 
 ```javascript
-MATTRVerifierSDK.initialise({ apiBaseUrl, applicationId }); // Initialise the SDK
+MATTRVerifierSDK.initialize({ apiBaseUrl, applicationId }); // Initialize the SDK
 const result = await MATTRVerifierSDK.requestCredentials({
   credentialQuery: [credentialQuery], // Define what credential query to use
   challenge: MATTRVerifierSDK.utils.generateChallenge(), // Pass a unique challenge
@@ -221,7 +221,7 @@ if (result.isErr()) {
 ## Request credentials with explicit same-device flow
 
 ```javascript
-MATTRVerifierSDK.initialise({ apiBaseUrl, applicationId });
+MATTRVerifierSDK.initialize({ apiBaseUrl, applicationId });
 const result = await MATTRVerifierSDK.requestCredentials({
   credentialQuery: [credentialQuery],
   challenge: MATTRVerifierSDK.utils.generateChallenge(),
@@ -232,7 +232,7 @@ const result = await MATTRVerifierSDK.requestCredentials({
 
 // result can be retrieved on redirect uri page. for example
 window.addEventListener("load", async () => {
-  MATTRVerifierSDK.initialise({ apiBaseUrl, applicationId });
+  MATTRVerifierSDK.initialize({ apiBaseUrl, applicationId });
   const result = await MATTRVerifierSDK.handleRedirectCallback();
 });
 ```
@@ -244,7 +244,7 @@ window.addEventListener("load", async () => {
 ## Request credentials with explicit cross-device flow
 
 ```javascript
-MATTRVerifierSDK.initialise({ apiBaseUrl, applicationId });
+MATTRVerifierSDK.initialize({ apiBaseUrl, applicationId });
 const result = await MATTRVerifierSDK.requestCredentials({
   credentialQuery: [credentialQuery],
   challenge: MATTRVerifierSDK.utils.generateChallenge(),

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:
  */
@@ -307,7 +307,7 @@ var AbortSessionErrorMessage;
     AbortSessionErrorMessage["FailedToAbortSession"] = "Failed to abort session";
 })(AbortSessionErrorMessage || (AbortSessionErrorMessage = {}));
 
-const InitialiseOptionsValidator = v__namespace.object({
+const InitializeOptionsValidator = v__namespace.object({
     apiBaseUrl: v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty("Must not be empty")),
     applicationId: v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty("Must not be empty"))
 });
@@ -350,20 +350,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;
 
@@ -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 initializeOptions = getInitializeOptions();
+    if (!initializeOptions) {
+        throw new Exception(InitializeErrorMessage.SdkNotInitialized);
+    }
+    const {apiBaseUrl: apiBaseUrl} = initializeOptions;
+    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({
@@ -869,12 +905,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);
@@ -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) {
@@ -964,11 +1001,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 neverthrow.err({
@@ -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,
@@ -1040,7 +1050,7 @@ exports.abortCredentialRequest = abortCredentialRequest;
 
 exports.handleRedirectCallback = handleRedirectCallback;
 
-exports.initialise = initialise;
+exports.initialize = initialize;
 
 exports.isDigitalCredentialsApiSupported = isDigitalCredentialsApiSupported;