@calimero-network/mero-js 29.7.6 → 29.7.7

package/dist/cloud-v2/client.d.ts

@@ -408,6 +408,13 @@ export interface ServedOrigins {
  */
 export interface SignInOptions {
     origin?: string | null;
+    /**
+     * Closes an open passkey prompt when it aborts (a Cancel button): the
+     * ceremony then rejects as a dismissed prompt does (`NotAllowedError`; in a
+     * sign-up's confirmation, {@link ConfirmCancelled}). Given to the
+     * {@link PasskeyProvider} as `signal`.
+     */
+    signal?: AbortSignal;
 }
 /**
  * {@link SignInOptions} for a sign-up, and the invite it is made with: an
@@ -648,9 +655,21 @@ export declare class CalimeroClient {
      */
     refresh(): Promise<CalimeroSession>;
     private exchangeRefresh;
+    /**
+     * End this session. The client is signed out whether or not the node
+     * answers: the revoke (`POST /auth/logout`) is attempted, and its failure
+     * (the node unreachable, say) is thrown after the session is dropped, so a
+     * caller can say the server may still hold it, but no request after this
+     * one carries its token.
+     */
     signOut(): Promise<void>;
-    /** End every session of the signed-in account, on every device, this one too. */
+    /**
+     * End every session of the signed-in account, on every device, this one
+     * too. Like {@link signOut}, this client is signed out even when the
+     * request fails, and the failure is thrown.
+     */
     signOutEverywhere(): Promise<void>;
+    private signingOut;
     /** Who the credential is: the account, how it signed in, and the package (`app`) and `origin` a session is bound to. */
     me(): Promise<MeInfo>;
     /**

package/dist/cloud-v2/client.js

@@ -511,13 +511,14 @@ export class CalimeroClient {
         const origin = this.pageOrigin(options);
         const invite = options.invite ? { invite: options.invite } : {};
         const begin = await this.begin('auth/passkey/register/begin', origin === undefined ? { name, ...invite } : { name, origin, ...invite }, origin);
-        const registration = await passkey.create(begin.options);
+        const signal = options.signal;
+        const registration = await (signal ? passkey.create(begin.options, { signal }) : passkey.create(begin.options));
         // The node checks the sign-up's confirmation with the user present, not
         // verified (core `api.rs`: `rp(node)`, `require_uv: false`), as it made
         // the passkey with `preferred`: asking `required` here would refuse a
         // security key without a PIN after it has made the passkey, leaving a
         // passkey with no account.
-        const session = await this.confirmed('POST', 'auth/passkey/register/finish', { challengeId: begin.challengeId, registration, ...invite }, passkey, undefined, 'preferred');
+        const session = await this.confirmed('POST', 'auth/passkey/register/finish', { challengeId: begin.challengeId, registration, ...invite }, passkey, undefined, 'preferred', signal);
         this.useSession(session);
         return session;
     }
@@ -537,7 +538,10 @@ export class CalimeroClient {
         const origin = this.pageOrigin(options);
         const begin = await this.begin('auth/passkey/login/begin', origin === undefined ? undefined : { origin }, origin);
         const rpId = begin.options.rpId ?? begin.options.rp?.id ?? '';
-        const assertion = await passkey.get(fromB64url(begin.options.challenge), rpId);
+        const challenge = fromB64url(begin.options.challenge);
+        const assertion = await (options.signal
+            ? passkey.get(challenge, rpId, undefined, { signal: options.signal })
+            : passkey.get(challenge, rpId));
         const session = await this.post('auth/passkey/login/finish', {
             challengeId: begin.challengeId,
             assertion,
@@ -617,16 +621,32 @@ export class CalimeroClient {
             this.useSession(session);
         return session;
     }
+    /**
+     * End this session. The client is signed out whether or not the node
+     * answers: the revoke (`POST /auth/logout`) is attempted, and its failure
+     * (the node unreachable, say) is thrown after the session is dropped, so a
+     * caller can say the server may still hold it, but no request after this
+     * one carries its token.
+     */
     async signOut() {
-        await this.post('auth/logout');
-        this.auth = undefined;
-        this.current = undefined;
+        await this.signingOut('auth/logout');
     }
-    /** End every session of the signed-in account, on every device, this one too. */
+    /**
+     * End every session of the signed-in account, on every device, this one
+     * too. Like {@link signOut}, this client is signed out even when the
+     * request fails, and the failure is thrown.
+     */
     async signOutEverywhere() {
-        await this.post('auth/logout-all');
-        this.auth = undefined;
-        this.current = undefined;
+        await this.signingOut('auth/logout-all');
+    }
+    async signingOut(path) {
+        try {
+            await this.post(path);
+        }
+        finally {
+            this.auth = undefined;
+            this.current = undefined;
+        }
     }
     /** Who the credential is: the account, how it signed in, and the package (`app`) and `origin` a session is bound to. */
     me() {
@@ -915,7 +935,7 @@ export class CalimeroClient {
     deleteConfirmed(path, passkey, body = {}) {
         return this.confirmed('DELETE', path, body, passkey);
     }
-    async confirmed(method, path, body, passkey, send = (b) => this.json(method, path, b), userVerification = 'required') {
+    async confirmed(method, path, body, passkey, send = (b) => this.json(method, path, b), userVerification = 'required', signal) {
         try {
             return await send(body);
         }
@@ -931,6 +951,7 @@ export class CalimeroClient {
                 // requirement the node names itself wins.
                 assertion = await passkey.get(fromB64url(d.challenge), d.rpId, d.allowCredentials, {
                     userVerification: userVerificationOf(d.userVerification, userVerification),
+                    ...(signal ? { signal } : {}),
                 });
             }
             catch (declined) {

package/dist/cloud-v2/index.d.ts

@@ -8,7 +8,7 @@ export { claimedRelease, fetchAttestedKey, freshCollateral, MOCK_QUOTE_HEADER }
 export type { AttestationDoc, CloudPolicy, CloudReleasePolicy } from './attestation.js';
 export { browserPasskey, b64url, fromB64url } from './passkey.js';
 export { MAX_RECOVERY_NONCE_BYTES, RECOVERY_DOMAIN, newRecoverySeed, parseRecoverySeed, recoveryMessage, recoveryPublicKey, recoverySeedText, signRecovery, } from './recovery.js';
-export type { AssertionJSON, PasskeyGetOptions, PasskeyProvider, PasskeyUserVerification, RegistrationJSON, } from './passkey.js';
+export type { AssertionJSON, PasskeyCreateOptions, PasskeyGetOptions, PasskeyProvider, PasskeyUserVerification, RegistrationJSON, } from './passkey.js';
 export { MAX_REPORT_PAGE, RELEASE_VERIFIER, compareVersions, confirmationCode, consentReturn, pageQuery, pendingApprovalsFrom, publisherBindingBytes, publisherBindingMessage, releaseConsent, releaseNotesUrl, stalledBy, upgradeConsent, verifyReleaseUrl, withdrawConsent, } from './approvals.js';
 export type { ActorKind, AppsReport, Authority, ClusterRelease, ConsentReleaseModel, ConsentRequest, ConsentResult, ConsentScope, ConsentStarted, ConsentStatus, OpenConsentOptions, Governance, LastUpgrade, OpsAppsReport, OpsOrgsReport, PageOptions, PendingApprovals, PendingRelease, PendingUpgrade, PublisherBindingInfo, PublisherProof, ReleaseDeadline, ReleaseRules, ReportScope, ReportedApp, ReportedBundle, ReportedRelease, ReportedReplica, UpgradeAuthority, } from './approvals.js';
 export { DEFAULT_ORG_CAPABILITIES, ORG_CAPABILITIES, orgCapabilities } from './capabilities.js';

package/dist/cloud-v2/passkey.d.ts

@@ -26,16 +26,32 @@ export interface PasskeyGetOptions {
      * `"preferred"` is enough.
      */
     userVerification?: PasskeyUserVerification;
+    /**
+     * Closes the open prompt when it aborts (a Cancel button, a page leaving).
+     * The browser provider then rejects as a dismissed prompt does
+     * (`NotAllowedError`), so the caller treats it as a cancel.
+     */
+    signal?: AbortSignal;
+}
+/** What a passkey creation takes beyond the node's options. */
+export interface PasskeyCreateOptions {
+    /** As {@link PasskeyGetOptions.signal}: aborting closes the prompt, rejecting as a cancel (`NotAllowedError`). */
+    signal?: AbortSignal;
 }
 /** Something that holds a passkey. */
 export interface PasskeyProvider {
-    /** Answer `navigator.credentials.create` for the node's options. */
-    create(options: Record<string, unknown>): Promise<RegistrationJSON>;
+    /**
+     * Answer `navigator.credentials.create` for the node's options.
+     * `createOptions.signal` closes the prompt when it aborts; a provider with
+     * no prompt to close may ignore it.
+     */
+    create(options: Record<string, unknown>, createOptions?: PasskeyCreateOptions): Promise<RegistrationJSON>;
     /**
      * Sign `challenge` (an assertion), optionally limited to
      * `allowCredentials`. `options.userVerification` is `"required"` when the
      * client answers a step-up confirmation (`"preferred"` for the sign-up's);
      * a provider that always verifies the user may ignore it.
+     * `options.signal` closes the prompt when it aborts.
      */
     get(challenge: Uint8Array, rpId: string, allowCredentials?: string[], options?: PasskeyGetOptions): Promise<AssertionJSON>;
 }

package/dist/cloud-v2/passkey.js

@@ -25,11 +25,22 @@ function cancelled(message) {
     error.name = "NotAllowedError";
     return error;
 }
-async function ask(method, options) {
+async function ask(method, options, signal, what) {
     const container = navigator.credentials;
     const own = globalThis.CredentialsContainer?.prototype?.[method];
     const call = own ?? container[method];
-    return call.call(container, options);
+    try {
+        return await call.call(container, signal ? { ...options, signal } : options);
+    }
+    catch (error) {
+        // An aborted `signal` rejects with its reason (an `AbortError` unless the
+        // caller gave another): the prompt was closed on purpose, so it reads as
+        // a dismissed one.
+        if (signal?.aborted || error?.name === "AbortError") {
+            throw Object.assign(cancelled(`${what} was cancelled`), { cause: error });
+        }
+        throw error;
+    }
 }
 /**
  * The node's algorithms with ES256 alone when it is among them. Some password
@@ -48,7 +59,7 @@ export function es256First(params) {
 /** The platform authenticator (Touch ID, Face ID, Windows Hello, a security key, a synced passkey). */
 export function browserPasskey() {
     return {
-        async create(options) {
+        async create(options, createOptions) {
             const o = options;
             const cred = (await ask("create", {
                 publicKey: {
@@ -64,7 +75,7 @@ export function browserPasskey() {
                     attestation: "none",
                     timeout: o.timeout,
                 },
-            }));
+            }, createOptions?.signal, "passkey creation"));
             if (!cred)
                 throw cancelled("passkey creation was cancelled");
             const r = cred.response;
@@ -84,7 +95,7 @@ export function browserPasskey() {
                         id: buf(fromB64url(id)),
                     })),
                 },
-            }));
+            }, options?.signal, "passkey sign-in"));
             if (!cred)
                 throw cancelled("passkey sign-in was cancelled");
             const r = cred.response;