@openid4vc/openid4vci 0.3.0-alpha-20250320203319 → 0.3.0-alpha-20250320211257

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/index.ts
-import { getGlobalConfig as getGlobalConfig2, setGlobalConfig } from "@openid4vc/utils";
+import { getGlobalConfig, setGlobalConfig } from "@openid4vc/utils";
 
 // src/credential-request/credential-request-configurations.ts
 import { arrayEqualsIgnoreOrder } from "@openid4vc/utils";
@@ -697,65 +697,42 @@ import {
 import {
   preAuthorizedCodeGrantIdentifier
 } from "@openid4vc/oauth2";
-import z11 from "zod";
-
-// ../utils/src/validation.ts
+import { zHttpsUrl as zHttpsUrl2 } from "@openid4vc/utils";
 import z10 from "zod";
-
-// ../utils/src/config.ts
-var GLOBAL_CONFIG = {
-  allowInsecureUrls: false
-};
-function getGlobalConfig() {
-  return GLOBAL_CONFIG;
-}
-
-// ../utils/src/validation.ts
-var zHttpsUrl2 = z10.string().url().refine(
-  (url) => {
-    const { allowInsecureUrls } = getGlobalConfig();
-    return allowInsecureUrls ? url.startsWith("http://") || url.startsWith("https://") : url.startsWith("https://");
-  },
-  { message: "url must be an https:// url" }
-);
-var zInteger2 = z10.number().int();
-var zHttpMethod = z10.enum(["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "TRACE", "CONNECT", "PATCH"]);
-
-// src/credential-offer/z-credential-offer.ts
-var zTxCode = z11.object({
-  input_mode: z11.union([z11.literal("numeric"), z11.literal("text")]).optional(),
-  length: z11.number().int().optional(),
-  description: z11.string().max(300).optional()
+var zTxCode = z10.object({
+  input_mode: z10.union([z10.literal("numeric"), z10.literal("text")]).optional(),
+  length: z10.number().int().optional(),
+  description: z10.string().max(300).optional()
 }).passthrough();
-var zCredentialOfferGrants = z11.object({
-  authorization_code: z11.object({
-    issuer_state: z11.string().optional(),
+var zCredentialOfferGrants = z10.object({
+  authorization_code: z10.object({
+    issuer_state: z10.string().optional(),
     authorization_server: zHttpsUrl2.optional()
   }).passthrough().optional(),
-  [preAuthorizedCodeGrantIdentifier]: z11.object({
-    "pre-authorized_code": z11.string(),
+  [preAuthorizedCodeGrantIdentifier]: z10.object({
+    "pre-authorized_code": z10.string(),
     tx_code: zTxCode.optional(),
     authorization_server: zHttpsUrl2.optional()
   }).passthrough().optional()
 }).passthrough();
-var zCredentialOfferObjectDraft14 = z11.object({
+var zCredentialOfferObjectDraft14 = z10.object({
   credential_issuer: zHttpsUrl2,
-  credential_configuration_ids: z11.array(z11.string()),
-  grants: z11.optional(zCredentialOfferGrants)
+  credential_configuration_ids: z10.array(z10.string()),
+  grants: z10.optional(zCredentialOfferGrants)
 }).passthrough();
-var zCredentialOfferObjectDraft11To14 = z11.object({
+var zCredentialOfferObjectDraft11To14 = z10.object({
   credential_issuer: zHttpsUrl2,
   // We don't support the inline offer objects from draft 11
-  credentials: z11.array(
-    z11.string({ message: "Only string credential identifiers are supported for draft 11 credential offers" })
+  credentials: z10.array(
+    z10.string({ message: "Only string credential identifiers are supported for draft 11 credential offers" })
   ),
-  grants: z11.optional(
-    z11.object({
+  grants: z10.optional(
+    z10.object({
       // Has extra param in draft 14, but doesn't matter for transform purposes
       authorization_code: zCredentialOfferGrants.shape.authorization_code,
-      [preAuthorizedCodeGrantIdentifier]: z11.object({
-        "pre-authorized_code": z11.string(),
-        user_pin_required: z11.optional(z11.boolean())
+      [preAuthorizedCodeGrantIdentifier]: z10.object({
+        "pre-authorized_code": z10.string(),
+        user_pin_required: z10.optional(z10.boolean())
       }).passthrough().optional()
     })
   )
@@ -780,7 +757,7 @@ var zCredentialOfferObjectDraft11To14 = z11.object({
   }
   return v14;
 }).pipe(zCredentialOfferObjectDraft14);
-var zCredentialOfferObject = z11.union([
+var zCredentialOfferObject = z10.union([
   // First prioritize draft 14 (and 13)
   zCredentialOfferObjectDraft14,
   // Then try parsing draft 11 and transform into draft 14
@@ -976,74 +953,74 @@ import {
 import { ContentType as ContentType2, isResponseContentType, parseWithErrorHandling as parseWithErrorHandling2 } from "@openid4vc/utils";
 
 // src/credential-request/z-credential-request.ts
-import z15 from "zod";
+import z14 from "zod";
 
 // src/credential-request/z-credential-request-common.ts
 import { zJwk as zJwk2 } from "@openid4vc/oauth2";
-import z14 from "zod";
+import z13 from "zod";
 
 // src/formats/proof-type/jwt/z-jwt-proof-type.ts
 import { zCompactJwt as zCompactJwt2, zJwtHeader as zJwtHeader2, zJwtPayload as zJwtPayload2 } from "@openid4vc/oauth2";
-import { zHttpsUrl as zHttpsUrl3, zInteger as zInteger3 } from "@openid4vc/utils";
-import z12 from "zod";
-var zJwtProofTypeIdentifier = z12.literal("jwt");
+import { zHttpsUrl as zHttpsUrl3, zInteger as zInteger2 } from "@openid4vc/utils";
+import z11 from "zod";
+var zJwtProofTypeIdentifier = z11.literal("jwt");
 var jwtProofTypeIdentifier = zJwtProofTypeIdentifier.value;
-var zCredentialRequestProofJwt = z12.object({
+var zCredentialRequestProofJwt = z11.object({
   proof_type: zJwtProofTypeIdentifier,
   jwt: zCompactJwt2
 });
 var zCredentialRequestJwtProofTypeHeader = zJwtHeader2.merge(
-  z12.object({
-    key_attestation: z12.optional(zCompactJwt2),
-    typ: z12.literal("openid4vci-proof+jwt")
+  z11.object({
+    key_attestation: z11.optional(zCompactJwt2),
+    typ: z11.literal("openid4vci-proof+jwt")
   })
 ).passthrough().refine(({ kid, jwk }) => jwk === void 0 || kid === void 0, {
   message: `Both 'jwk' and 'kid' are defined. Only one is allowed`
 }).refine(({ trust_chain, kid }) => !trust_chain || !kid, {
   message: `When 'trust_chain' is provided, 'kid' is required`
 });
-var zCredentialRequestJwtProofTypePayload = z12.object({
+var zCredentialRequestJwtProofTypePayload = z11.object({
   ...zJwtPayload2.shape,
   aud: zHttpsUrl3,
-  iat: zInteger3
+  iat: zInteger2
 }).passthrough();
 
 // src/formats/proof-type/attestation/z-attestation-proof-type.ts
 import { zCompactJwt as zCompactJwt3 } from "@openid4vc/oauth2";
-import z13 from "zod";
-var zAttestationProofTypeIdentifier = z13.literal("attestation");
+import z12 from "zod";
+var zAttestationProofTypeIdentifier = z12.literal("attestation");
 var attestationProofTypeIdentifier = zAttestationProofTypeIdentifier.value;
-var zCredentialRequestProofAttestation = z13.object({
+var zCredentialRequestProofAttestation = z12.object({
   proof_type: zAttestationProofTypeIdentifier,
   attestation: zCompactJwt3
 });
 var zCredentialRequestAttestationProofTypePayload = zKeyAttestationJwtPayloadForUse("proof_type.attestation");
 
 // src/credential-request/z-credential-request-common.ts
-var zCredentialRequestProofCommon = z14.object({
-  proof_type: z14.string()
+var zCredentialRequestProofCommon = z13.object({
+  proof_type: z13.string()
 }).passthrough();
 var allCredentialRequestProofs = [zCredentialRequestProofJwt, zCredentialRequestProofAttestation];
-var zCredentialRequestProof = z14.union([
+var zCredentialRequestProof = z13.union([
   zCredentialRequestProofCommon,
-  z14.discriminatedUnion("proof_type", allCredentialRequestProofs)
+  z13.discriminatedUnion("proof_type", allCredentialRequestProofs)
 ]);
-var zCredentialRequestProofsCommon = z14.record(z14.string(), z14.array(z14.unknown()));
-var zCredentialRequestProofs = z14.object({
-  [zJwtProofTypeIdentifier.value]: z14.optional(z14.array(zCredentialRequestProofJwt.shape.jwt)),
-  [zAttestationProofTypeIdentifier.value]: z14.optional(z14.array(zCredentialRequestProofAttestation.shape.attestation))
+var zCredentialRequestProofsCommon = z13.record(z13.string(), z13.array(z13.unknown()));
+var zCredentialRequestProofs = z13.object({
+  [zJwtProofTypeIdentifier.value]: z13.optional(z13.array(zCredentialRequestProofJwt.shape.jwt)),
+  [zAttestationProofTypeIdentifier.value]: z13.optional(z13.array(zCredentialRequestProofAttestation.shape.attestation))
 });
-var zCredentialRequestCommon = z14.object({
+var zCredentialRequestCommon = z13.object({
   proof: zCredentialRequestProof.optional(),
-  proofs: z14.optional(
-    z14.intersection(zCredentialRequestProofsCommon, zCredentialRequestProofs).refine((proofs) => Object.values(proofs).length === 1, {
+  proofs: z13.optional(
+    z13.intersection(zCredentialRequestProofsCommon, zCredentialRequestProofs).refine((proofs) => Object.values(proofs).length === 1, {
       message: `The 'proofs' object in a credential request should contain exactly one attribute`
     })
   ),
-  credential_response_encryption: z14.object({
+  credential_response_encryption: z13.object({
     jwk: zJwk2,
-    alg: z14.string(),
-    enc: z14.string()
+    alg: z13.string(),
+    enc: z13.string()
   }).passthrough().optional()
 }).passthrough().refine(({ proof, proofs }) => !(proof !== void 0 && proofs !== void 0), {
   message: `Both 'proof' and 'proofs' are defined. Only one is allowed`
@@ -1060,27 +1037,27 @@ var allCredentialRequestFormats = [
 var allCredentialRequestFormatIdentifiers = allCredentialRequestFormats.map(
   (format) => format.shape.format.value
 );
-var zAuthorizationDetailsCredentialRequest = z15.object({
-  credential_identifier: z15.string(),
+var zAuthorizationDetailsCredentialRequest = z14.object({
+  credential_identifier: z14.string(),
   // Cannot be present if credential identifier is present
-  format: z15.never({ message: "'format' cannot be defined when 'credential_identifier' is set." }).optional()
+  format: z14.never({ message: "'format' cannot be defined when 'credential_identifier' is set." }).optional()
 });
-var zCredentialRequestFormatNoCredentialIdentifier = z15.object({
-  format: z15.string(),
-  credential_identifier: z15.never({ message: "'credential_identifier' cannot be defined when 'format' is set." }).optional()
+var zCredentialRequestFormatNoCredentialIdentifier = z14.object({
+  format: z14.string(),
+  credential_identifier: z14.never({ message: "'credential_identifier' cannot be defined when 'format' is set." }).optional()
 }).passthrough();
 var zCredenialRequestDraft14WithFormat = zCredentialRequestCommon.and(zCredentialRequestFormatNoCredentialIdentifier).transform((data, ctx) => {
   if (!allCredentialRequestFormatIdentifiers.includes(data.format)) return data;
-  const result = z15.object({}).passthrough().and(z15.discriminatedUnion("format", allCredentialRequestFormats)).safeParse(data);
+  const result = z14.object({}).passthrough().and(z14.discriminatedUnion("format", allCredentialRequestFormats)).safeParse(data);
   if (result.success) {
     return result.data;
   }
   for (const issue of result.error.issues) {
     ctx.addIssue(issue);
   }
-  return z15.NEVER;
+  return z14.NEVER;
 });
-var zCredentialRequestDraft14 = z15.union([
+var zCredentialRequestDraft14 = z14.union([
   zCredenialRequestDraft14WithFormat,
   zCredentialRequestCommon.and(zAuthorizationDetailsCredentialRequest)
 ]);
@@ -1097,7 +1074,7 @@ var zCredentialRequestDraft11To14 = zCredentialRequestCommon.and(zCredentialRequ
   for (const issue of result.error.issues) {
     ctx.addIssue(issue);
   }
-  return z15.NEVER;
+  return z14.NEVER;
 }).pipe(zCredentialRequestDraft14);
 var zCredentialRequestDraft14To11 = zCredentialRequestDraft14.refine(
   (data) => data.credential_identifier === void 0,
@@ -1115,15 +1092,15 @@ var zCredentialRequestDraft14To11 = zCredentialRequestDraft14.refine(
   for (const issue of result.error.issues) {
     ctx.addIssue(issue);
   }
-  return z15.NEVER;
+  return z14.NEVER;
 });
-var zCredentialRequest = z15.union([zCredentialRequestDraft14, zCredentialRequestDraft11To14]);
+var zCredentialRequest = z14.union([zCredentialRequestDraft14, zCredentialRequestDraft11To14]);
 
 // src/credential-request/z-credential-response.ts
-import z17 from "zod";
+import z16 from "zod";
 
 // ../oauth2/src/common/z-oauth2-error.ts
-import z16 from "zod";
+import z15 from "zod";
 var Oauth2ErrorCodes = /* @__PURE__ */ ((Oauth2ErrorCodes4) => {
   Oauth2ErrorCodes4["ServerError"] = "server_error";
   Oauth2ErrorCodes4["InvalidTarget"] = "invalid_target";
@@ -1160,21 +1137,21 @@ var Oauth2ErrorCodes = /* @__PURE__ */ ((Oauth2ErrorCodes4) => {
   Oauth2ErrorCodes4["WalletUnavailable"] = "wallet_unavailable";
   return Oauth2ErrorCodes4;
 })(Oauth2ErrorCodes || {});
-var zOauth2ErrorResponse = z16.object({
-  error: z16.union([z16.nativeEnum(Oauth2ErrorCodes), z16.string()]),
-  error_description: z16.string().optional(),
-  error_uri: z16.string().optional()
+var zOauth2ErrorResponse = z15.object({
+  error: z15.union([z15.nativeEnum(Oauth2ErrorCodes), z15.string()]),
+  error_description: z15.string().optional(),
+  error_uri: z15.string().optional()
 }).passthrough();
 
 // src/credential-request/z-credential-response.ts
-var zCredentialEncoding = z17.union([z17.string(), z17.record(z17.string(), z17.any())]);
-var zCredentialResponse = z17.object({
-  credential: z17.optional(zCredentialEncoding),
-  credentials: z17.optional(z17.array(zCredentialEncoding)),
-  transaction_id: z17.string().optional(),
-  c_nonce: z17.string().optional(),
-  c_nonce_expires_in: z17.number().int().optional(),
-  notification_id: z17.string().optional()
+var zCredentialEncoding = z16.union([z16.string(), z16.record(z16.string(), z16.any())]);
+var zCredentialResponse = z16.object({
+  credential: z16.optional(zCredentialEncoding),
+  credentials: z16.optional(z16.array(zCredentialEncoding)),
+  transaction_id: z16.string().optional(),
+  c_nonce: z16.string().optional(),
+  c_nonce_expires_in: z16.number().int().optional(),
+  notification_id: z16.string().optional()
 }).passthrough().refine(
   (value) => {
     const { credential, credentials, transaction_id } = value;
@@ -1184,10 +1161,10 @@ var zCredentialResponse = z17.object({
     message: `Exactly one of 'credential', 'credentials', or 'transaction_id' MUST be defined.`
   }
 );
-var zCredentialErrorResponse = z17.object({
+var zCredentialErrorResponse = z16.object({
   ...zOauth2ErrorResponse.shape,
-  c_nonce: z17.string().optional(),
-  c_nonce_expires_in: z17.number().int().optional()
+  c_nonce: z16.string().optional(),
+  c_nonce_expires_in: z16.number().int().optional()
 }).passthrough();
 
 // src/credential-request/retrieve-credentials.ts
@@ -1435,11 +1412,11 @@ import { InvalidFetchResponseError as InvalidFetchResponseError2 } from "@openid
 import { ContentType as ContentType3, ValidationError as ValidationError3, createZodFetcher as createZodFetcher2, parseWithErrorHandling as parseWithErrorHandling6 } from "@openid4vc/utils";
 
 // src/nonce/z-nonce.ts
-import { zInteger as zInteger4 } from "@openid4vc/utils";
-import z18 from "zod";
-var zNonceResponse = z18.object({
-  c_nonce: z18.string(),
-  c_nonce_expires_in: z18.optional(zInteger4)
+import { zInteger as zInteger3 } from "@openid4vc/utils";
+import z17 from "zod";
+var zNonceResponse = z17.object({
+  c_nonce: z17.string(),
+  c_nonce_expires_in: z17.optional(zInteger3)
 }).passthrough();
 
 // src/nonce/nonce-request.ts
@@ -1482,15 +1459,15 @@ import {
 import { ContentType as ContentType4, isResponseContentType as isResponseContentType2, parseWithErrorHandling as parseWithErrorHandling7 } from "@openid4vc/utils";
 
 // src/notification/z-notification.ts
-import z19 from "zod";
-var zNotificationEvent = z19.enum(["credential_accepted", "credential_failure", "credential_deleted"]);
-var zNotificationRequest = z19.object({
-  notification_id: z19.string(),
+import z18 from "zod";
+var zNotificationEvent = z18.enum(["credential_accepted", "credential_failure", "credential_deleted"]);
+var zNotificationRequest = z18.object({
+  notification_id: z18.string(),
   event: zNotificationEvent,
-  event_description: z19.optional(z19.string())
+  event_description: z18.optional(z18.string())
 }).passthrough();
-var zNotificationErrorResponse = z19.object({
-  error: z19.enum(["invalid_notification_id", "invalid_notification_request"])
+var zNotificationErrorResponse = z18.object({
+  error: z18.enum(["invalid_notification_id", "invalid_notification_request"])
 }).passthrough();
 
 // src/notification/notification.ts
@@ -1925,7 +1902,7 @@ function createCredentialResponse(options) {
 
 // src/credential-request/parse-credential-request.ts
 import { parseWithErrorHandling as parseWithErrorHandling9 } from "@openid4vc/utils";
-import z20 from "zod";
+import z19 from "zod";
 function parseCredentialRequest(options) {
   const credentialRequest = parseWithErrorHandling9(
     zCredentialRequest,
@@ -1937,7 +1914,7 @@ function parseCredentialRequest(options) {
   if (knownProofs.success) {
     proofs = knownProofs.data;
   }
-  const knownProof = z20.union(allCredentialRequestProofs).safeParse(credentialRequest.proof);
+  const knownProof = z19.union(allCredentialRequestProofs).safeParse(credentialRequest.proof);
   if (knownProof.success && knownProof.data.proof_type === jwtProofTypeIdentifier) {
     proofs = { [jwtProofTypeIdentifier]: [knownProof.data.jwt] };
   } else if (knownProof.success && knownProof.data.proof_type === attestationProofTypeIdentifier) {
@@ -1954,7 +1931,7 @@ function parseCredentialRequest(options) {
     return {
       // Removes all claims that are not specific to this format
       format: parseWithErrorHandling9(
-        z20.union(allCredentialRequestFormats),
+        z19.union(allCredentialRequestFormats),
         credentialRequest,
         "Unable to validate format specific properties from credential request"
       ),
@@ -2118,7 +2095,7 @@ export {
   credentialsSupportedToCredentialConfigurationsSupported,
   extractScopesForCredentialConfigurationIds,
   getCredentialConfigurationsMatchingRequestFormat,
-  getGlobalConfig2 as getGlobalConfig,
+  getGlobalConfig,
   setGlobalConfig
 };
 //# sourceMappingURL=index.mjs.map