Digital Credentials: Rename DigitalCredentialsRequest to DigitalCredentialRequest

digital-credentials/allow-attribute.https.html

@@ -105,8 +105,9 @@
                         const options = {
                             digital: {
                                 // Results in TypeError when allowed, NotAllowedError when disallowed
-                                providers: [],
+                                requests: [],
                             },
+                            mediation: "required",
                         };
                         const { data } = await new Promise((resolve) => {
                             window.addEventListener("message", resolve, {
@@ -118,14 +119,14 @@
                             );
                         });
                         const { name, message } = data;
+                        const fullMessage = `${iframe.outerHTML} - ${message}`;
                         if (expectIsAllowed) {
-                          assert_true(name == "TypeError" ||
-                                          (name == "NotAllowedError" && message.includes("transient activation")),
-                                      `${iframe.outerHTML} - ${message}`);
+                            assert_true(
+                                name == "TypeError" || name == "NotAllowedError",
+                                fullMessage
+                            );
                         } else {
-                          assert_equals(name, "NotAllowedError", `${iframe.outerHTML} - ${message}`);
-                          assert_false(message.includes("transient activation"),
-                                       `${iframe.outerHTML} - ${message}`);
+                            assert_equals(name, "NotAllowedError", fullMessage);
                         }
                         iframe.remove();
                     }, `Policy to use: ${details.policy}, is cross-origin: ${details.crossOrigin}, is allowed by policy: ${details.expectIsAllowed}`);

digital-credentials/dc-types.ts

@@ -6,25 +6,25 @@ export type CredentialMediationRequirement =
   | "silent";
 
 /**
- * @see https://wicg.github.io/digital-credentials/#dom-identityrequestprovider
+ * @see https://wicg.github.io/digital-credentials/#dom-digitalcredentialrequest
  */
-export interface IdentityRequestProvider {
+export interface DigitalCredentialRequest {
   protocol: string;
-  request: object;
+  data: object;
 }
 
 /**
  * @see https://wicg.github.io/digital-credentials/#dom-digitalcredentialrequestoptions
  */
 export interface DigitalCredentialRequestOptions {
   /**
-   * The list of identity request providers
+   * The list of credential requests.
    */
-  providers: IdentityRequestProvider[] | any;
+  requests: DigitalCredentialRequest[] | any;
 }
 
 /**
- * @see https://wicg.github.io/digital-credentials/#extensions-to-credentialrequestoptions-dictionary
+ * @see https://wicg.github.io/digital-credentials/#extensions-to-credentialrequestoptions
  */
 export interface CredentialRequestOptions {
   /**

digital-credentials/support/helper.js

@@ -2,60 +2,60 @@
 // Import the types from the TypeScript file
 /**
  * @typedef {import('../dc-types').ProviderType} ProviderType
- * @typedef {import('../dc-types').IdentityRequestProvider} IdentityRequestProvider
+ * @typedef {import('../dc-types').DigitalCredentialRequest} DigitalCredentialRequest
  * @typedef {import('../dc-types').DigitalCredentialRequestOptions} DigitalCredentialRequestOptions
  * @typedef {import('../dc-types').CredentialRequestOptions} CredentialRequestOptions
  * @typedef {import('../dc-types').SendMessageData} SendMessageData
  */
 /**
- * @param {ProviderType | ProviderType[]} [providersToUse=["default"]]
+ * @param {ProviderType | ProviderType[]} [requestsToUse=["default"]]
  * @param {CredentialMediationRequirement} [mediation="required"]
  * @returns {CredentialRequestOptions}
  */
-export function makeGetOptions(providersToUse, mediation = "required") {
-  if (typeof providersToUse === "string") {
-    if (providersToUse === "default" || providersToUse === "openid4vp"){
-      return makeGetOptions([providersToUse], mediation);
+export function makeGetOptions(requestsToUse, mediation = "required") {
+  if (typeof requestsToUse === "string") {
+    if (requestsToUse === "default" || requestsToUse === "openid4vp") {
+      return makeGetOptions([requestsToUse], mediation);
     }
   }
-  if (!Array.isArray(providersToUse) || !providersToUse?.length) {
-    return { digital: { providers: providersToUse }, mediation };
+  if (!Array.isArray(requestsToUse) || !requestsToUse?.length) {
+    return { digital: { requests: requestsToUse }, mediation };
   }
-  const providers = [];
-  for (const provider of providersToUse) {
-    switch (provider) {
+  const requests = [];
+  for (const request of requestsToUse) {
+    switch (request) {
       case "openid4vp":
-        providers.push(makeOID4VPDict());
+        requests.push(makeOID4VPDict());
         break;
       case "default":
-        providers.push(makeIdentityRequestProvider(undefined, undefined));
+        requests.push(makeDigitalCredentialRequest(undefined, undefined));
         break;
       default:
-        throw new Error(`Unknown provider type: ${provider}`);
+        throw new Error(`Unknown request type: ${request}`);
     }
   }
-  return { digital: { providers }, mediation };
+  return { digital: { requests }, mediation };
 }
 /**
  *
  * @param {string} protocol
- * @param {object} request
- * @returns {IdentityRequestProvider}
+ * @param {object} data
+ * @returns {DigitalCredentialRequest}
  */
-function makeIdentityRequestProvider(protocol = "protocol", request = {}) {
+function makeDigitalCredentialRequest(protocol = "protocol", data = {}) {
   return {
     protocol,
-    request,
+    data,
   };
 }
 
 /**
- * Representation of a digital identity object with an OpenID4VP provider.
+ * Representation of an OpenID4VP request.
  *
- * @returns {IdentityRequestProvider}
+ * @returns {DigitalCredentialRequest}
  **/
 function makeOID4VPDict() {
-  return makeIdentityRequestProvider("openid4vp", {
+  return makeDigitalCredentialRequest("openid4vp", {
     // Canonical example of an OpenID4VP request coming soon.
   });
 }