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

package/dist/typings/index.d.ts

@@ -1,11 +1,11 @@
-import { initialise, requestCredentials, handleRedirectCallback, abortCredentialRequest, isDigitalCredentialsApiSupported } from "./verifier";
+import { initialize, requestCredentials, handleRedirectCallback, abortCredentialRequest, isDigitalCredentialsApiSupported } from "./verifier";
 import { HandleRedirectCallbackError, HandleRedirectCallbackErrorType } from "./verifier/handleRedirectCallback";
-import { InitialiseOptions, RequestCredentialsOptions, OpenId4vpConfigurationSameDeviceOptions, OpenId4vpConfigurationCrossDeviceOptions, OpenId4vpConfigurationAutoDetectOptions, RequestCredentialsError, RequestCredentialsErrorType, CredentialQuery, CredentialQueryClaim, OpenidPresentationCredentialProfileSupported, Mode, RequestCredentialsResponse, AbortSessionErrorType, HandleRedirectCallbackResponse, Claim, ClaimData, ClaimType, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, MobileCredentialResponseErrorCode, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, MobileCredentialVerificationReasonType, CredentialBrandingImageFormat } from "./verifier/types";
+import { InitializeOptions, RequestCredentialsOptions, OpenId4vpConfigurationSameDeviceOptions, OpenId4vpConfigurationCrossDeviceOptions, OpenId4vpConfigurationAutoDetectOptions, RequestCredentialsError, RequestCredentialsErrorType, CredentialQuery, CredentialQueryClaim, OpenidPresentationCredentialProfileSupported, Mode, RequestCredentialsResponse, AbortSessionErrorType, HandleRedirectCallbackResponse, Claim, ClaimData, ClaimType, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, MobileCredentialResponseErrorCode, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, MobileCredentialVerificationReasonType, CredentialBrandingImageFormat } from "./verifier/types";
 export { Mode, OpenidPresentationCredentialProfileSupported, MobileCredentialVerificationReasonType, RequestCredentialsErrorType, AbortSessionErrorType, HandleRedirectCallbackErrorType, CredentialBrandingImageFormat, ClaimType, MobileCredentialResponseErrorCode, };
-export type { InitialiseOptions, RequestCredentialsOptions, OpenId4vpConfigurationSameDeviceOptions, OpenId4vpConfigurationCrossDeviceOptions, OpenId4vpConfigurationAutoDetectOptions, CredentialQuery, CredentialQueryClaim, RequestCredentialsResponse, RequestCredentialsError, Claim, ClaimData, HandleRedirectCallbackResponse, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, HandleRedirectCallbackError, };
+export type { InitializeOptions, RequestCredentialsOptions, OpenId4vpConfigurationSameDeviceOptions, OpenId4vpConfigurationCrossDeviceOptions, OpenId4vpConfigurationAutoDetectOptions, CredentialQuery, CredentialQueryClaim, RequestCredentialsResponse, RequestCredentialsError, Claim, ClaimData, HandleRedirectCallbackResponse, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, HandleRedirectCallbackError, };
 declare const utils: {
     generateChallenge: () => string;
     getVersion: () => string;
     unwrap: <T = unknown>(result: import("neverthrow").Result<T, unknown>, errMessage?: string) => T;
 };
-export { initialise, requestCredentials, handleRedirectCallback, abortCredentialRequest, isDigitalCredentialsApiSupported, utils, };
+export { initialize, requestCredentials, handleRedirectCallback, abortCredentialRequest, isDigitalCredentialsApiSupported, utils, };

package/dist/typings/verifier/index.d.ts

@@ -1,4 +1,4 @@
-export { initialise } from "./initialise";
+export { initialize } from "./initialize";
 export { requestCredentials } from "./requestCredentials";
 export { handleRedirectCallback } from "./handleRedirectCallback";
 export { abortCredentialRequest } from "./abortCredentialRequest";

package/dist/typings/verifier/initialize.d.ts

@@ -0,0 +1,12 @@
+import { InitializeOptions } from "./types";
+export declare enum InitializeErrorMessage {
+    SdkNotInitialized = "SDK not initialized"
+}
+/**
+ * Initializes the SDK with the provided options.
+ *
+ * @param options - The options to initialize the SDK with.
+ */
+export declare const initialize: (options: InitializeOptions) => void;
+export declare const getInitializeOptions: () => InitializeOptions | undefined;
+export declare const clearInitializeOptions: () => void;

package/dist/typings/verifier/types/credential-presentation.d.ts

@@ -120,7 +120,7 @@ export type CredentialQuery = {
     profile: OpenidPresentationCredentialProfileSupported;
     /**
      * 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`).
@@ -321,6 +321,7 @@ export type RequestCredentialsWithDcApiOptions = {
     apiBaseUrl: string;
     sessionId: string;
     sessionKey: string;
+    sessionTtl: number;
     challenge: string;
     request: Record<string, unknown>;
 };

package/dist/typings/verifier/types/verifier-web-sdk.d.ts

@@ -219,13 +219,13 @@ export type HandleRedirectCallbackResponse = {
     sessionId: string;
 };
 /**
- * Options for the initialise function
+ * Options for the initialize function
  */
-export type InitialiseOptions = {
+export type InitializeOptions = {
     apiBaseUrl: string;
     applicationId: string;
 };
-export declare const InitialiseOptionsValidator: v.ObjectSchema<{
+export declare const InitializeOptionsValidator: v.ObjectSchema<{
     readonly apiBaseUrl: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Must not be empty">]>;
     readonly applicationId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Must not be empty">]>;
 }, undefined>;
@@ -235,6 +235,7 @@ export declare const InitialiseOptionsValidator: v.ObjectSchema<{
 export type CreatePresentationSession = {
     readonly sessionId: string;
     readonly sessionKey: string;
+    readonly sessionTimeoutId?: number;
 };
 /**
  * Struct for a stored presentation session
@@ -242,4 +243,5 @@ export type CreatePresentationSession = {
 export type StoredPresentationSession = {
     readonly sessionId: string;
     readonly sessionKey?: string;
+    readonly sessionTimeoutId?: number;
 };

package/dist/typings/verifier/utils.d.ts

@@ -1,6 +1,6 @@
 import { Result } from "neverthrow";
 import { SafeFetchValidateResponseError } from "../common/safeFetch";
-import { CreateSessionRequest, ExchangeSessionResultResponse, GetSessionStatusRequest, GetSessionStatusResponse, AbortSessionRequest, InitialiseOptions, CreateSessionResponse } from "./types";
+import { CreateSessionRequest, ExchangeSessionResultResponse, GetSessionStatusRequest, GetSessionStatusResponse, AbortSessionRequest, InitializeOptions, CreateSessionResponse } from "./types";
 /**
  * Generates a challenge string using the window.crypto API.
  *
@@ -26,7 +26,7 @@ export declare const getHashParamValue: (hash: string, param: string) => string
  * @param walletProviderId - optional, The ID of the wallet provider, if not provided the default wallet provider will be used.
  * @returns A promise that resolves to a result containing either the created session response or an error.
  */
-export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, walletProviderId, dcApiSupported, applicationId, }: CreateSessionRequest & InitialiseOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateResponseError>>;
+export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, walletProviderId, dcApiSupported, applicationId, }: CreateSessionRequest & InitializeOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateResponseError>>;
 /**
  * Abort a session with the provided parameters.
  *
@@ -42,7 +42,7 @@ export declare const abortSession: ({ apiBaseUrl, sessionId, sessionKey, }: Abor
  * @param sessionKey - The authorization key for performing operations for the session.
  * @returns A promise that resolves to a result containing either the session status response or an error.
  */
-export declare const getSessionStatus: ({ apiBaseUrl, sessionId, sessionKey, }: GetSessionStatusRequest & InitialiseOptions) => Promise<Result<GetSessionStatusResponse, SafeFetchValidateResponseError>>;
+export declare const getSessionStatus: ({ apiBaseUrl, sessionId, sessionKey, }: GetSessionStatusRequest & InitializeOptions) => Promise<Result<GetSessionStatusResponse, SafeFetchValidateResponseError>>;
 /**
  * Exchange the result of a session using the provided parameters.
  *

package/dist/verifier-js.development.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:
  *
@@ -1427,7 +1427,7 @@
     (function(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"))
     });
@@ -1464,43 +1464,51 @@
             });
         }
     };
-    let initialiseOptions = undefined;
-    var InitialiseErrorMessage;
-    (function(InitialiseErrorMessage) {
-        InitialiseErrorMessage["SdkNotInitialised"] = "SDK not initialised";
-    })(InitialiseErrorMessage || (InitialiseErrorMessage = {}));
-    const initialise = options => {
-        assertType(InitialiseOptionsValidator, "Invalid initialise options")(options);
-        initialiseOptions = options;
+    let initializeOptions = undefined;
+    var InitializeErrorMessage;
+    (function(InitializeErrorMessage) {
+        InitializeErrorMessage["SdkNotInitialized"] = "SDK not initialized";
+    })(InitializeErrorMessage || (InitializeErrorMessage = {}));
+    const initialize = options => {
+        assertType(InitializeOptionsValidator, "Invalid initialize options")(options);
+        initializeOptions = options;
     };
-    const getInitialiseOptions = () => initialiseOptions;
+    const getInitializeOptions = () => initializeOptions;
     let sessionAbortController = undefined;
     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;
     };
     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;
     var isMobile_2 = isMobile;
@@ -1782,25 +1790,49 @@
             window.addEventListener(WindowEventListenerType.message, listener, false);
         }));
     };
+    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;
@@ -1821,9 +1853,11 @@
         }
         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({
@@ -1962,12 +1996,12 @@
     };
     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);
@@ -1990,13 +2024,14 @@
         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) {
@@ -2051,11 +2086,11 @@
         HandleRedirectCallbackErrorMessage["FailedToGetSessionResult"] = "Failed to get session result";
     })(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({
@@ -2089,32 +2124,6 @@
             sessionId: result.value.sessionId
         });
     };
-    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,
@@ -2122,7 +2131,7 @@
     };
     exports.abortCredentialRequest = abortCredentialRequest;
     exports.handleRedirectCallback = handleRedirectCallback;
-    exports.initialise = initialise;
+    exports.initialize = initialize;
     exports.isDigitalCredentialsApiSupported = isDigitalCredentialsApiSupported;
     exports.requestCredentials = requestCredentials;
     exports.utils = utils;