@atlasauth/angular 0.8.0 → 0.9.0

package/dist/esm2022/lib/components/flow-controller.mjs

@@ -1,5 +1,5 @@
 import { signal } from '@angular/core';
-import { advanceWithCaptcha, atlasCaptchaLabels, createCaptchaController, createSignUp, fetchInstanceSettings, flowNeedsCaptcha, signInCaptchaOptions, flowFromPending, initialFlow, nextStep, offeredFirstFactors, pollAttempt, prepareFactor, planFirstFactor, shouldKeepPolling, } from '@atlasauth/js';
+import { advanceWithCaptcha, atlasCaptchaLabels, createCaptchaController, createPasskeySignUp, createSignUp, finishPasskeySignUp, fetchInstanceSettings, fetchLastSignInMethod, createMfaEnrollment, acknowledgeRecoveryCodes, pendingRecoveryCodes, mfaChoicesFrom, prepareSecondFactorCode, resendSignUpVerification, flowNeedsCaptcha, signInCaptchaOptions, flowFromPending, initialFlow, nextStep, offeredFirstFactors, pollAttempt, prepareFactor, planFirstFactor, shouldKeepPolling, } from '@atlasauth/js';
 import { EN_US, translate } from '../i18n';
 /**
  * The server-driven sign-in / sign-up engine, shared by `<atlas-sign-in>` and
@@ -26,6 +26,11 @@ export class AtlasFlowController {
      * resolves, or when the server could not be reached.
      */
     settings = signal(null);
+    /**
+     * The method this browser last signed in with (`password`, `oauth_github`, …)
+     * for the "Last used" hint; null when none, or the instance turned it off.
+     */
+    lastMethod = signal(null);
     /** The sign-in captcha (identifier step / `needs_captcha` challenge). */
     captcha = createCaptchaController(undefined, {
         // The Atlas captcha's words follow the form's catalog (read when drawn).
@@ -45,6 +50,21 @@ export class AtlasFlowController {
      * otherwise.
      */
     preparedFactor = signal(null);
+    /**
+     * "Email me a code instead" at the second factor ({@link sendEmailSecondFactor}):
+     * in flight, where the code went, or why it was not sent. Null until asked,
+     * and again once the flow leaves that step.
+     */
+    emailSecondFactor = signal(null);
+    /** "Text me a code instead" at the second factor ({@link sendSmsSecondFactor}): as {@link emailSecondFactor}. */
+    smsSecondFactor = signal(null);
+    /**
+     * The MFA enrolment step (`needs_mfa_enrollment`): the authenticator app's
+     * setup (QR code, setup key) or a texted code. Started and reset with the flow.
+     */
+    enrollment;
+    /** {@link enrollment}'s state, for templates. */
+    enrollmentState;
     pollTimer = null;
     identifier = '';
     constructor(client, reload, pending, 
@@ -56,7 +76,23 @@ export class AtlasFlowController {
         // Seeded from a redirect that came back mid-flow (e.g. OAuth needing a second
         // factor) so the user resumes at the demanded step instead of starting over.
         this.state = signal(pending ? flowFromPending(pending) : initialFlow);
+        this.enrollment = createMfaEnrollment(this.client, () => this.mfaChoices());
+        this.enrollmentState = signal(this.enrollment.state);
+        this.enrollment.subscribe((next) => this.enrollmentState.set(next));
         this.syncCaptcha();
+        this.syncEnrollment();
+    }
+    /** What the app lets the MFA steps offer (from {@link settings}). */
+    mfaChoices() {
+        return mfaChoicesFrom(this.settings()?.account);
+    }
+    /** Start the enrolment step for its attempt, or reset it once the flow leaves. */
+    syncEnrollment() {
+        const attempt = this.state().attempt;
+        if (attempt?.status === 'needs_mfa_enrollment' && attempt.id)
+            this.enrollment.start(attempt.id);
+        else
+            this.enrollment.reset();
     }
     /** Fetch the instance's public settings and draw whatever captcha they require. */
     async loadSettings() {
@@ -64,6 +100,8 @@ export class AtlasFlowController {
         if (loaded) {
             this.settings.set(loaded);
             this.syncCaptcha();
+            if (loaded.account.lastSignInMethod)
+                this.lastMethod.set(await fetchLastSignInMethod(this.client));
         }
     }
     /**
@@ -118,11 +156,18 @@ export class AtlasFlowController {
         this.signUpCaptchaDrawn.set(this.signUpCaptcha.needed);
     }
     setState(next) {
+        const previousId = this.state().attempt?.id ?? null;
         this.state.set(next);
         // A prepared factor belongs to the first-factor step it was sent for.
         if (next.attempt?.status !== 'needs_first_factor')
             this.preparedFactor.set(null);
+        // An emailed second-factor code belongs to the second-factor step of this attempt.
+        if (next.attempt?.status !== 'needs_second_factor' || (next.attempt?.id ?? null) !== previousId) {
+            this.emailSecondFactor.set(null);
+            this.smsSecondFactor.set(null);
+        }
         this.syncCaptcha();
+        this.syncEnrollment();
         this.autoSend();
     }
     autoSentFor = null;
@@ -171,7 +216,72 @@ export class AtlasFlowController {
         });
         await this.finish(next);
     }
+    /**
+     * "Email me a code instead" at the second factor (the instance's
+     * `account.emailSecondFactor`): mails a code to the account's verified email;
+     * it is then posted with {@link submit} like any 2FA code.
+     */
+    async sendEmailSecondFactor() {
+        await this.sendSecondFactorCode('email_code', this.emailSecondFactor);
+    }
+    /**
+     * "Text me a code instead" at the second factor (where the app offers texted
+     * codes, {@link mfaChoices}`().sms`): texts a code to the account's enrolled
+     * phone; it is then posted with {@link submit} like any 2FA code.
+     */
+    async sendSmsSecondFactor() {
+        await this.sendSecondFactorCode('sms', this.smsSecondFactor);
+    }
+    async sendSecondFactorCode(strategy, out) {
+        const id = this.state().attempt?.id;
+        if (!id)
+            return;
+        out.set({ busy: true });
+        try {
+            const { sentTo } = await prepareSecondFactorCode(this.client, id, strategy);
+            out.set({ sentTo });
+        }
+        catch (error) {
+            out.set({ error: error instanceof Error ? error.message : this.t('error.generic') });
+        }
+    }
+    /** Resend a sign-up's emailed code / link (the earlier one stops working). */
+    async resendSignUp() {
+        this.state.update((current) => ({ ...current, busy: true, errors: [] }));
+        this.state.set(await resendSignUpVerification(this.client, this.state()));
+    }
+    /**
+     * Start a passkey-only sign-up (`POST /v1/client/sign_ups/passkey`) from the
+     * create-account form's values — no password. Offered when the instance's
+     * `account.passkeySignUp` is set.
+     */
+    async createWithPasskey(values, consent = true) {
+        this.state.update((current) => ({ ...current, busy: true, errors: [] }));
+        await this.finish(await createPasskeySignUp(this.client, values, { consent, captcha: this.signUpCaptcha, t: this.t }));
+    }
+    /** The passkey-only sign-up's last step: create the passkey, and with it the account. */
+    async createPasskey() {
+        this.state.update((current) => ({ ...current, busy: true, errors: [] }));
+        await this.finish(await finishPasskeySignUp(this.client, this.state(), { t: this.t }));
+    }
+    /**
+     * The recovery codes an MFA enrolment just completed the sign-in with, shown
+     * once before it finishes ({@link saveRecoveryCodes}); null otherwise. They
+     * live only in this controller's memory.
+     */
+    recoveryCodes() {
+        return pendingRecoveryCodes(this.state());
+    }
+    /** "I've saved my codes": forget the recovery codes and finish the sign-in. */
+    async saveRecoveryCodes() {
+        await this.finish(acknowledgeRecoveryCodes(this.state()));
+    }
     async finish(next) {
+        // An enrolment's recovery codes are shown first; `saveRecoveryCodes` finishes.
+        if (pendingRecoveryCodes(next)) {
+            this.setState({ ...next, busy: false });
+            return;
+        }
         if (next.attempt?.status === 'complete') {
             // Stays busy until this browser actually holds the session: the completion
             // alone says nothing about whether the cookie was kept.
@@ -209,6 +319,9 @@ export class AtlasFlowController {
             void (async () => {
                 const { state: next, ticket } = await pollAttempt(this.client, this.state());
                 this.setState(next);
+                // e.g. a passkey sign-up whose email was just proven: only this tab can go on.
+                if (!ticket && !shouldKeepPolling(next))
+                    this.stopPolling();
                 if (!ticket || !next.attempt)
                     return;
                 // The ticket is exchanged by a normal request, so no session token ever
@@ -236,4 +349,4 @@ export class AtlasFlowController {
         this.signUpCaptcha.destroy();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-controller.js","sourceRoot":"","sources":["../../../../src/lib/components/flow-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,MAAM,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAEL,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,YAAY,EACZ,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,WAAW,EACX,QAAQ,EACR,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,eAAe,EACf,iBAAiB,GAIlB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,mBAAmB;IA+BX;IACA;IAGA;IAlCV,KAAK,CAA4B;IAC1C;;;;OAIG;IACM,QAAQ,GAAG,MAAM,CAA0B,IAAI,CAAC,CAAC;IAC1D,yEAAyE;IAChE,OAAO,GAAsB,uBAAuB,CAAC,SAAS,EAAE;QACvE,yEAAyE;QACzE,WAAW,EAAE,GAAG,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC;KAC9C,CAAC,CAAC;IACH,qDAAqD;IAC5C,aAAa,GAAsB,uBAAuB,CAAC,SAAS,EAAE;QAC7E,WAAW,EAAE,GAAG,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC;KAC9C,CAAC,CAAC;IACH,wEAAwE;IAC/D,YAAY,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IACtC,8EAA8E;IACrE,kBAAkB,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5C;;;;OAIG;IACM,cAAc,GAAG,MAAM,CAAsB,IAAI,CAAC,CAAC;IACpD,SAAS,GAA0C,IAAI,CAAC;IACxD,UAAU,GAAG,EAAE,CAAC;IAExB,YACmB,MAAkB,EAClB,MAA8B,EAC/C,OAA8C;IAC9C,sEAAsE;IACrD,IAA6B,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAJ3D,WAAM,GAAN,MAAM,CAAY;QAClB,WAAM,GAAN,MAAM,CAAwB;QAG9B,MAAC,GAAD,CAAC,CAA0D;QAE5E,8EAA8E;QAC9E,6EAA6E;QAC7E,IAAI,CAAC,KAAK,GAAG,MAAM,CAAY,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;QACjF,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAED,mFAAmF;IACnF,KAAK,CAAC,YAAY;QAChB,MAAM,MAAM,GAAG,MAAM,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxD,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC1B,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,YAAY;QACV,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,OAAO,CAAC;QACrC,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAChD,OAAO,IAAI,EAAE,IAAI,KAAK,sBAAsB;YAC1C,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,aAAa,CAAC;YACtE,CAAC,CAAC,EAAE,CAAC;IACT,CAAC;IAED;;;;OAIG;IACH,sBAAsB;QACpB,OAAO,IAAI,CAAC,QAAQ,EAAE,EAAE,aAAa,CAAC,cAAc,KAAK,KAAK,CAAC;IACjE,CAAC;IAED,uFAAuF;IACvF,sBAAsB;QACpB,OAAO,IAAI,CAAC,QAAQ,EAAE,EAAE,aAAa,CAAC,aAAa,KAAK,KAAK,CAAC;IAChE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,QAAsB;QAClC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAAE,OAAO;QACpD,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QACzE,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,QAAQ,CAAC,CAAC;QACtE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM;YAAE,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC7D,CAAC;IAED,gFAAgF;IACxE,WAAW;QACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,CAAC,SAAS,CACpB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CACvF,CAAC;QACF,MAAM,UAAU,GAAG,QAAQ,EAAE,YAAY,CAAC,MAAM,CAAC;QACjD,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;YAC3B,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,CAAC,KAAK,CAAC,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;SACvD,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3C,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACzD,CAAC;IAEO,QAAQ,CAAC,IAAe;QAC9B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACrB,sEAAsE;QACtE,IAAI,IAAI,CAAC,OAAO,EAAE,MAAM,KAAK,oBAAoB;YAAE,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjF,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAEO,WAAW,GAAkB,IAAI,CAAC;IAC1C;;;;OAIG;IACK,QAAQ;QACd,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE,IAAI,IAAI,CAAC;QAC5C,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,WAAW,KAAK,EAAE,IAAI,IAAI,CAAC,cAAc,EAAE;YAAE,OAAO;QACpE,IAAI,eAAe,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,QAAQ,KAAK,YAAY;YAAE,OAAO;QAC3E,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;QACtB,KAAK,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;IAClC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,CAAC,MAA8B;QACzC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QAEzE,MAAM,GAAG,GAAG,MAAM,kBAAkB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE;YACtE,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,CAAC,EAAE,IAAI,CAAC,CAAC;SACV,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;QACjC,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,CAAC,MAA8B,EAAE,OAAO,GAAG,IAAI;QACzD,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QACzE,MAAM,IAAI,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE;YACnD,OAAO;YACP,OAAO,EAAE,IAAI,CAAC,aAAa;YAC3B,CAAC,EAAE,IAAI,CAAC,CAAC;SACV,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,IAAe;QAClC,IAAI,IAAI,CAAC,OAAO,EAAE,MAAM,KAAK,UAAU,EAAE,CAAC;YACxC,2EAA2E;YAC3E,wDAAwD;YACxD,IAAI,CAAC,QAAQ,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YACvC,IAAI,SAAS,GAAG,IAAI,CAAC;YACrB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;gBAChB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE;oBAChE,UAAU,EAAG,IAAI,CAAC,OAA2B,CAAC,EAAE;oBAChD,MAAM,EAAE,IAAI,CAAC,MAAM;iBACpB,CAAC,CAAC;gBACH,SAAS,GAAG,GAAG,CAAC,EAAE,CAAC;YACrB,CAAC;YACD,MAAM,IAAI,GAAG,SAAS,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAChD,IAAI,CAAC,QAAQ,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7D,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACpB,2EAA2E;YAC3E,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC;IACH,CAAC;IAED,sEAAsE;IACtE,WAAW;QACT,IAAI,iBAAiB,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC;YACpC,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC;IACH,CAAC;IAEO,YAAY;QAClB,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC3B,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE;YAChC,KAAK,CAAC,KAAK,IAAI,EAAE;gBACf,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;gBAC7E,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACpB,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO;oBAAE,OAAO;gBAErC,wEAAwE;gBACxE,oBAAoB;gBACpB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE;oBAChE,UAAU,EAAG,IAAI,CAAC,OAA2B,CAAC,EAAE;oBAChD,MAAM;iBACP,CAAC,CAAC;gBACH,MAAM,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;gBAC7C,IAAI,CAAC,QAAQ,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;gBACtD,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,CAAC,CAAC,EAAE,CAAC;QACP,CAAC,EAAE,KAAK,CAAC,CAAC;IACZ,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,CAAC;IACH,CAAC;IAED,gGAAgG;IAChG,OAAO;QACL,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;QACvB,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;IAC/B,CAAC;CACF","sourcesContent":["import { WritableSignal, signal } from '@angular/core';\nimport {\n  FapiClient,\n  advanceWithCaptcha,\n  atlasCaptchaLabels,\n  createCaptchaController,\n  createSignUp,\n  fetchInstanceSettings,\n  flowNeedsCaptcha,\n  signInCaptchaOptions,\n  flowFromPending,\n  initialFlow,\n  nextStep,\n  offeredFirstFactors,\n  pollAttempt,\n  prepareFactor,\n  planFirstFactor,\n  shouldKeepPolling,\n  type CaptchaController,\n  type FlowState,\n  type InstanceSettings,\n} from '@atlasauth/js';\nimport { EN_US, translate } from '../i18n';\n\n/**\n * The server-driven sign-in / sign-up engine, shared by `<atlas-sign-in>` and\n * `<atlas-sign-up>` — the Angular counterpart of React's `useFlow` hook.\n *\n * It owns no decision about what comes next: every status comes back from the\n * server via `advance`, and this controller only posts whatever the current step\n * needs and re-renders the returned status. State lives in a signal so templates\n * update whether the app runs zoned or zoneless.\n *\n * `<atlas-sign-up>` starts the attempt with {@link create}\n * (`POST /v1/client/sign_ups`); the emailed-code step then runs through the same\n * {@link submit}. Both flows draw the instance's captcha (from\n * {@link loadSettings}) when it is required.\n */\nexport class AtlasFlowController {\n  readonly state: WritableSignal<FlowState>;\n  /**\n   * The instance's public sign-in / sign-up settings (captcha, sign-up fields,\n   * legal consent) from `GET /v1/appearance`; null until {@link loadSettings}\n   * resolves, or when the server could not be reached.\n   */\n  readonly settings = signal<InstanceSettings | null>(null);\n  /** The sign-in captcha (identifier step / `needs_captcha` challenge). */\n  readonly captcha: CaptchaController = createCaptchaController(undefined, {\n    // The Atlas captcha's words follow the form's catalog (read when drawn).\n    atlasLabels: () => atlasCaptchaLabels(this.t),\n  });\n  /** The sign-up captcha (the create-account step). */\n  readonly signUpCaptcha: CaptchaController = createCaptchaController(undefined, {\n    atlasLabels: () => atlasCaptchaLabels(this.t),\n  });\n  /** Whether {@link captcha} currently draws a widget (for templates). */\n  readonly captchaDrawn = signal(false);\n  /** Whether {@link signUpCaptcha} currently draws a widget (for templates). */\n  readonly signUpCaptchaDrawn = signal(false);\n  /**\n   * The first factor the server was asked to send ({@link prepare}) on the\n   * current `needs_first_factor` step — the form then collects its code. Null\n   * otherwise.\n   */\n  readonly preparedFactor = signal<'email_code' | null>(null);\n  private pollTimer: ReturnType<typeof setInterval> | null = null;\n  private identifier = '';\n\n  constructor(\n    private readonly client: FapiClient,\n    private readonly reload: () => Promise<boolean>,\n    pending: { id: string; status: string } | null,\n    /** Resolves the captcha messages' catalog keys. Defaults to en-US. */\n    private readonly t: (key: string) => string = (key) => translate(EN_US, key),\n  ) {\n    // Seeded from a redirect that came back mid-flow (e.g. OAuth needing a second\n    // factor) so the user resumes at the demanded step instead of starting over.\n    this.state = signal<FlowState>(pending ? flowFromPending(pending) : initialFlow);\n    this.syncCaptcha();\n  }\n\n  /** Fetch the instance's public settings and draw whatever captcha they require. */\n  async loadSettings(): Promise<void> {\n    const loaded = await fetchInstanceSettings(this.client);\n    if (loaded) {\n      this.settings.set(loaded);\n      this.syncCaptcha();\n    }\n  }\n\n  /**\n   * The first factors to offer on a `needs_first_factor` step: the server's list\n   * without email code / link while the app cannot deliver email\n   * (`settings.emailDelivery.available === false`). Empty on any other step.\n   */\n  firstFactors(): string[] {\n    const attempt = this.state().attempt;\n    const step = attempt ? nextStep(attempt) : null;\n    return step?.kind === 'collect_first_factor'\n      ? offeredFirstFactors(step.strategies, this.settings()?.emailDelivery)\n      : [];\n  }\n\n  /**\n   * True when email + password sign-up cannot complete because the app cannot\n   * send the verification email (`settings.emailDelivery.passwordSignUp === false`):\n   * `<atlas-sign-up>` shows the \"can't send email\" notice instead of the form.\n   */\n  signUpEmailUnavailable(): boolean {\n    return this.settings()?.emailDelivery.passwordSignUp === false;\n  }\n\n  /** False when a password reset email cannot be delivered — hide \"Forgot password?\". */\n  passwordResetAvailable(): boolean {\n    return this.settings()?.emailDelivery.passwordReset !== false;\n  }\n\n  /**\n   * Ask the server to email a sign-in code for the current `needs_first_factor`\n   * step (`POST …/prepare_first_factor`); the form then collects the code, which\n   * {@link submit} posts as the `email_code` strategy.\n   */\n  async prepare(strategy: 'email_code'): Promise<void> {\n    if (!this.firstFactors().includes(strategy)) return;\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    const next = await prepareFactor(this.client, this.state(), strategy);\n    this.setState(next);\n    if (!next.errors.length) this.preparedFactor.set(strategy);\n  }\n\n  /** Keep both captchas in step with the settings and the flow's current step. */\n  private syncCaptcha(): void {\n    const settings = this.settings();\n    const state = this.state();\n    this.captcha.configure(\n      signInCaptchaOptions(settings?.captchaFlows.signIn, state, () => void this.submit({})),\n    );\n    const signUpFlow = settings?.captchaFlows.signUp;\n    this.signUpCaptcha.configure({\n      flow: signUpFlow,\n      active: !state.attempt && flowNeedsCaptcha(signUpFlow),\n    });\n    this.captchaDrawn.set(this.captcha.needed);\n    this.signUpCaptchaDrawn.set(this.signUpCaptcha.needed);\n  }\n\n  private setState(next: FlowState): void {\n    this.state.set(next);\n    // A prepared factor belongs to the first-factor step it was sent for.\n    if (next.attempt?.status !== 'needs_first_factor') this.preparedFactor.set(null);\n    this.syncCaptcha();\n    this.autoSend();\n  }\n\n  private autoSentFor: string | null = null;\n  /**\n   * With no password on offer, email the code as soon as the server asks for a\n   * first factor — once per attempt, so a failed send waits for the user's retry\n   * (the \"Email me a code\" button) instead of looping.\n   */\n  private autoSend(): void {\n    const id = this.state().attempt?.id ?? null;\n    if (!id || this.autoSentFor === id || this.preparedFactor()) return;\n    if (planFirstFactor(this.firstFactors()).autoSend !== 'email_code') return;\n    this.autoSentFor = id;\n    void this.prepare('email_code');\n  }\n\n  /**\n   * Advance the flow with the values the user typed. On completion, exchange the\n   * one-time ticket for cookies over a same-origin request (FAPI is cross-origin\n   * and cannot set the cookie on its own response), then re-boot so the rest of\n   * the app sees a signed-in user.\n   */\n  async submit(values: Record<string, string>): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n\n    const out = await advanceWithCaptcha(this.client, this.state(), values, {\n      captcha: this.captcha,\n      identifier: this.identifier,\n      t: this.t,\n    });\n    this.identifier = out.identifier;\n    await this.finish(out.state);\n  }\n\n  /**\n   * Create an account (`POST /v1/client/sign_ups`) from a create-account form's\n   * values — email, password and any configured sign-up fields — carrying the\n   * sign-up captcha's token when the instance requires one. The emailed code is\n   * then posted with {@link submit}.\n   */\n  async create(values: Record<string, string>, consent = true): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    const next = await createSignUp(this.client, values, {\n      consent,\n      captcha: this.signUpCaptcha,\n      t: this.t,\n    });\n    await this.finish(next);\n  }\n\n  private async finish(next: FlowState): Promise<void> {\n    if (next.attempt?.status === 'complete') {\n      // Stays busy until this browser actually holds the session: the completion\n      // alone says nothing about whether the cookie was kept.\n      this.setState({ ...next, busy: true });\n      let exchanged = true;\n      if (next.ticket) {\n        const res = await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket: next.ticket,\n        });\n        exchanged = res.ok;\n      }\n      const kept = exchanged && (await this.reload());\n      this.setState({ ...next, busy: false, sessionKept: kept });\n    } else {\n      this.setState(next);\n      // A magic-link step may now be pollable (a link opened on another device).\n      this.syncPolling();\n    }\n  }\n\n  /** Start/stop the §5.3 magic-link poll to match the current state. */\n  syncPolling(): void {\n    if (shouldKeepPolling(this.state())) {\n      this.startPolling();\n    } else {\n      this.stopPolling();\n    }\n  }\n\n  private startPolling(): void {\n    if (this.pollTimer) return;\n    this.pollTimer = setInterval(() => {\n      void (async () => {\n        const { state: next, ticket } = await pollAttempt(this.client, this.state());\n        this.setState(next);\n        if (!ticket || !next.attempt) return;\n\n        // The ticket is exchanged by a normal request, so no session token ever\n        // appears in a URL.\n        const res = await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket,\n        });\n        const kept = res.ok && (await this.reload());\n        this.setState({ ...this.state(), sessionKept: kept });\n        this.stopPolling();\n      })();\n    }, 2_000);\n  }\n\n  private stopPolling(): void {\n    if (this.pollTimer) {\n      clearInterval(this.pollTimer);\n      this.pollTimer = null;\n    }\n  }\n\n  /** Release the poll timer and the captcha widgets — call from the component's `ngOnDestroy`. */\n  destroy(): void {\n    this.stopPolling();\n    this.captcha.destroy();\n    this.signUpCaptcha.destroy();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-controller.js","sourceRoot":"","sources":["../../../../src/lib/components/flow-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { WritableSignal, signal } from '@angular/core';\nimport {\n  FapiClient,\n  advanceWithCaptcha,\n  atlasCaptchaLabels,\n  createCaptchaController,\n  createPasskeySignUp,\n  createSignUp,\n  finishPasskeySignUp,\n  fetchInstanceSettings,\n  fetchLastSignInMethod,\n  createMfaEnrollment,\n  acknowledgeRecoveryCodes,\n  pendingRecoveryCodes,\n  mfaChoicesFrom,\n  prepareSecondFactorCode,\n  resendSignUpVerification,\n  flowNeedsCaptcha,\n  signInCaptchaOptions,\n  flowFromPending,\n  initialFlow,\n  nextStep,\n  offeredFirstFactors,\n  pollAttempt,\n  prepareFactor,\n  planFirstFactor,\n  shouldKeepPolling,\n  type CaptchaController,\n  type FlowState,\n  type InstanceSettings,\n  type MfaChoices,\n  type MfaEnrollmentController,\n  type MfaEnrollmentState,\n} from '@atlasauth/js';\nimport { EN_US, translate } from '../i18n';\n\n/**\n * The server-driven sign-in / sign-up engine, shared by `<atlas-sign-in>` and\n * `<atlas-sign-up>` — the Angular counterpart of React's `useFlow` hook.\n *\n * It owns no decision about what comes next: every status comes back from the\n * server via `advance`, and this controller only posts whatever the current step\n * needs and re-renders the returned status. State lives in a signal so templates\n * update whether the app runs zoned or zoneless.\n *\n * `<atlas-sign-up>` starts the attempt with {@link create}\n * (`POST /v1/client/sign_ups`); the emailed-code step then runs through the same\n * {@link submit}. Both flows draw the instance's captcha (from\n * {@link loadSettings}) when it is required.\n */\nexport class AtlasFlowController {\n  readonly state: WritableSignal<FlowState>;\n  /**\n   * The instance's public sign-in / sign-up settings (captcha, sign-up fields,\n   * legal consent) from `GET /v1/appearance`; null until {@link loadSettings}\n   * resolves, or when the server could not be reached.\n   */\n  readonly settings = signal<InstanceSettings | null>(null);\n  /**\n   * The method this browser last signed in with (`password`, `oauth_github`, …)\n   * for the \"Last used\" hint; null when none, or the instance turned it off.\n   */\n  readonly lastMethod = signal<string | null>(null);\n  /** The sign-in captcha (identifier step / `needs_captcha` challenge). */\n  readonly captcha: CaptchaController = createCaptchaController(undefined, {\n    // The Atlas captcha's words follow the form's catalog (read when drawn).\n    atlasLabels: () => atlasCaptchaLabels(this.t),\n  });\n  /** The sign-up captcha (the create-account step). */\n  readonly signUpCaptcha: CaptchaController = createCaptchaController(undefined, {\n    atlasLabels: () => atlasCaptchaLabels(this.t),\n  });\n  /** Whether {@link captcha} currently draws a widget (for templates). */\n  readonly captchaDrawn = signal(false);\n  /** Whether {@link signUpCaptcha} currently draws a widget (for templates). */\n  readonly signUpCaptchaDrawn = signal(false);\n  /**\n   * The first factor the server was asked to send ({@link prepare}) on the\n   * current `needs_first_factor` step — the form then collects its code. Null\n   * otherwise.\n   */\n  readonly preparedFactor = signal<'email_code' | null>(null);\n  /**\n   * \"Email me a code instead\" at the second factor ({@link sendEmailSecondFactor}):\n   * in flight, where the code went, or why it was not sent. Null until asked,\n   * and again once the flow leaves that step.\n   */\n  readonly emailSecondFactor = signal<{ busy?: boolean; sentTo?: string; error?: string } | null>(null);\n  /** \"Text me a code instead\" at the second factor ({@link sendSmsSecondFactor}): as {@link emailSecondFactor}. */\n  readonly smsSecondFactor = signal<{ busy?: boolean; sentTo?: string; error?: string } | null>(null);\n  /**\n   * The MFA enrolment step (`needs_mfa_enrollment`): the authenticator app's\n   * setup (QR code, setup key) or a texted code. Started and reset with the flow.\n   */\n  readonly enrollment: MfaEnrollmentController;\n  /** {@link enrollment}'s state, for templates. */\n  readonly enrollmentState: WritableSignal<MfaEnrollmentState>;\n  private pollTimer: ReturnType<typeof setInterval> | null = null;\n  private identifier = '';\n\n  constructor(\n    private readonly client: FapiClient,\n    private readonly reload: () => Promise<boolean>,\n    pending: { id: string; status: string } | null,\n    /** Resolves the captcha messages' catalog keys. Defaults to en-US. */\n    private readonly t: (key: string) => string = (key) => translate(EN_US, key),\n  ) {\n    // Seeded from a redirect that came back mid-flow (e.g. OAuth needing a second\n    // factor) so the user resumes at the demanded step instead of starting over.\n    this.state = signal<FlowState>(pending ? flowFromPending(pending) : initialFlow);\n    this.enrollment = createMfaEnrollment(this.client, () => this.mfaChoices());\n    this.enrollmentState = signal<MfaEnrollmentState>(this.enrollment.state);\n    this.enrollment.subscribe((next) => this.enrollmentState.set(next));\n    this.syncCaptcha();\n    this.syncEnrollment();\n  }\n\n  /** What the app lets the MFA steps offer (from {@link settings}). */\n  mfaChoices(): MfaChoices {\n    return mfaChoicesFrom(this.settings()?.account);\n  }\n\n  /** Start the enrolment step for its attempt, or reset it once the flow leaves. */\n  private syncEnrollment(): void {\n    const attempt = this.state().attempt;\n    if (attempt?.status === 'needs_mfa_enrollment' && attempt.id) this.enrollment.start(attempt.id);\n    else this.enrollment.reset();\n  }\n\n  /** Fetch the instance's public settings and draw whatever captcha they require. */\n  async loadSettings(): Promise<void> {\n    const loaded = await fetchInstanceSettings(this.client);\n    if (loaded) {\n      this.settings.set(loaded);\n      this.syncCaptcha();\n      if (loaded.account.lastSignInMethod) this.lastMethod.set(await fetchLastSignInMethod(this.client));\n    }\n  }\n\n  /**\n   * The first factors to offer on a `needs_first_factor` step: the server's list\n   * without email code / link while the app cannot deliver email\n   * (`settings.emailDelivery.available === false`). Empty on any other step.\n   */\n  firstFactors(): string[] {\n    const attempt = this.state().attempt;\n    const step = attempt ? nextStep(attempt) : null;\n    return step?.kind === 'collect_first_factor'\n      ? offeredFirstFactors(step.strategies, this.settings()?.emailDelivery)\n      : [];\n  }\n\n  /**\n   * True when email + password sign-up cannot complete because the app cannot\n   * send the verification email (`settings.emailDelivery.passwordSignUp === false`):\n   * `<atlas-sign-up>` shows the \"can't send email\" notice instead of the form.\n   */\n  signUpEmailUnavailable(): boolean {\n    return this.settings()?.emailDelivery.passwordSignUp === false;\n  }\n\n  /** False when a password reset email cannot be delivered — hide \"Forgot password?\". */\n  passwordResetAvailable(): boolean {\n    return this.settings()?.emailDelivery.passwordReset !== false;\n  }\n\n  /**\n   * Ask the server to email a sign-in code for the current `needs_first_factor`\n   * step (`POST …/prepare_first_factor`); the form then collects the code, which\n   * {@link submit} posts as the `email_code` strategy.\n   */\n  async prepare(strategy: 'email_code'): Promise<void> {\n    if (!this.firstFactors().includes(strategy)) return;\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    const next = await prepareFactor(this.client, this.state(), strategy);\n    this.setState(next);\n    if (!next.errors.length) this.preparedFactor.set(strategy);\n  }\n\n  /** Keep both captchas in step with the settings and the flow's current step. */\n  private syncCaptcha(): void {\n    const settings = this.settings();\n    const state = this.state();\n    this.captcha.configure(\n      signInCaptchaOptions(settings?.captchaFlows.signIn, state, () => void this.submit({})),\n    );\n    const signUpFlow = settings?.captchaFlows.signUp;\n    this.signUpCaptcha.configure({\n      flow: signUpFlow,\n      active: !state.attempt && flowNeedsCaptcha(signUpFlow),\n    });\n    this.captchaDrawn.set(this.captcha.needed);\n    this.signUpCaptchaDrawn.set(this.signUpCaptcha.needed);\n  }\n\n  private setState(next: FlowState): void {\n    const previousId = this.state().attempt?.id ?? null;\n    this.state.set(next);\n    // A prepared factor belongs to the first-factor step it was sent for.\n    if (next.attempt?.status !== 'needs_first_factor') this.preparedFactor.set(null);\n    // An emailed second-factor code belongs to the second-factor step of this attempt.\n    if (next.attempt?.status !== 'needs_second_factor' || (next.attempt?.id ?? null) !== previousId) {\n      this.emailSecondFactor.set(null);\n      this.smsSecondFactor.set(null);\n    }\n    this.syncCaptcha();\n    this.syncEnrollment();\n    this.autoSend();\n  }\n\n  private autoSentFor: string | null = null;\n  /**\n   * With no password on offer, email the code as soon as the server asks for a\n   * first factor — once per attempt, so a failed send waits for the user's retry\n   * (the \"Email me a code\" button) instead of looping.\n   */\n  private autoSend(): void {\n    const id = this.state().attempt?.id ?? null;\n    if (!id || this.autoSentFor === id || this.preparedFactor()) return;\n    if (planFirstFactor(this.firstFactors()).autoSend !== 'email_code') return;\n    this.autoSentFor = id;\n    void this.prepare('email_code');\n  }\n\n  /**\n   * Advance the flow with the values the user typed. On completion, exchange the\n   * one-time ticket for cookies over a same-origin request (FAPI is cross-origin\n   * and cannot set the cookie on its own response), then re-boot so the rest of\n   * the app sees a signed-in user.\n   */\n  async submit(values: Record<string, string>): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n\n    const out = await advanceWithCaptcha(this.client, this.state(), values, {\n      captcha: this.captcha,\n      identifier: this.identifier,\n      t: this.t,\n    });\n    this.identifier = out.identifier;\n    await this.finish(out.state);\n  }\n\n  /**\n   * Create an account (`POST /v1/client/sign_ups`) from a create-account form's\n   * values — email, password and any configured sign-up fields — carrying the\n   * sign-up captcha's token when the instance requires one. The emailed code is\n   * then posted with {@link submit}.\n   */\n  async create(values: Record<string, string>, consent = true): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    const next = await createSignUp(this.client, values, {\n      consent,\n      captcha: this.signUpCaptcha,\n      t: this.t,\n    });\n    await this.finish(next);\n  }\n\n  /**\n   * \"Email me a code instead\" at the second factor (the instance's\n   * `account.emailSecondFactor`): mails a code to the account's verified email;\n   * it is then posted with {@link submit} like any 2FA code.\n   */\n  async sendEmailSecondFactor(): Promise<void> {\n    await this.sendSecondFactorCode('email_code', this.emailSecondFactor);\n  }\n\n  /**\n   * \"Text me a code instead\" at the second factor (where the app offers texted\n   * codes, {@link mfaChoices}`().sms`): texts a code to the account's enrolled\n   * phone; it is then posted with {@link submit} like any 2FA code.\n   */\n  async sendSmsSecondFactor(): Promise<void> {\n    await this.sendSecondFactorCode('sms', this.smsSecondFactor);\n  }\n\n  private async sendSecondFactorCode(\n    strategy: 'sms' | 'email_code',\n    out: WritableSignal<{ busy?: boolean; sentTo?: string; error?: string } | null>,\n  ): Promise<void> {\n    const id = this.state().attempt?.id;\n    if (!id) return;\n    out.set({ busy: true });\n    try {\n      const { sentTo } = await prepareSecondFactorCode(this.client, id, strategy);\n      out.set({ sentTo });\n    } catch (error) {\n      out.set({ error: error instanceof Error ? error.message : this.t('error.generic') });\n    }\n  }\n\n  /** Resend a sign-up's emailed code / link (the earlier one stops working). */\n  async resendSignUp(): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    this.state.set(await resendSignUpVerification(this.client, this.state()));\n  }\n\n  /**\n   * Start a passkey-only sign-up (`POST /v1/client/sign_ups/passkey`) from the\n   * create-account form's values — no password. Offered when the instance's\n   * `account.passkeySignUp` is set.\n   */\n  async createWithPasskey(values: Record<string, string>, consent = true): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    await this.finish(await createPasskeySignUp(this.client, values, { consent, captcha: this.signUpCaptcha, t: this.t }));\n  }\n\n  /** The passkey-only sign-up's last step: create the passkey, and with it the account. */\n  async createPasskey(): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    await this.finish(await finishPasskeySignUp(this.client, this.state(), { t: this.t }));\n  }\n\n  /**\n   * The recovery codes an MFA enrolment just completed the sign-in with, shown\n   * once before it finishes ({@link saveRecoveryCodes}); null otherwise. They\n   * live only in this controller's memory.\n   */\n  recoveryCodes(): string[] | null {\n    return pendingRecoveryCodes(this.state());\n  }\n\n  /** \"I've saved my codes\": forget the recovery codes and finish the sign-in. */\n  async saveRecoveryCodes(): Promise<void> {\n    await this.finish(acknowledgeRecoveryCodes(this.state()));\n  }\n\n  private async finish(next: FlowState): Promise<void> {\n    // An enrolment's recovery codes are shown first; `saveRecoveryCodes` finishes.\n    if (pendingRecoveryCodes(next)) {\n      this.setState({ ...next, busy: false });\n      return;\n    }\n    if (next.attempt?.status === 'complete') {\n      // Stays busy until this browser actually holds the session: the completion\n      // alone says nothing about whether the cookie was kept.\n      this.setState({ ...next, busy: true });\n      let exchanged = true;\n      if (next.ticket) {\n        const res = await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket: next.ticket,\n        });\n        exchanged = res.ok;\n      }\n      const kept = exchanged && (await this.reload());\n      this.setState({ ...next, busy: false, sessionKept: kept });\n    } else {\n      this.setState(next);\n      // A magic-link step may now be pollable (a link opened on another device).\n      this.syncPolling();\n    }\n  }\n\n  /** Start/stop the §5.3 magic-link poll to match the current state. */\n  syncPolling(): void {\n    if (shouldKeepPolling(this.state())) {\n      this.startPolling();\n    } else {\n      this.stopPolling();\n    }\n  }\n\n  private startPolling(): void {\n    if (this.pollTimer) return;\n    this.pollTimer = setInterval(() => {\n      void (async () => {\n        const { state: next, ticket } = await pollAttempt(this.client, this.state());\n        this.setState(next);\n        // e.g. a passkey sign-up whose email was just proven: only this tab can go on.\n        if (!ticket && !shouldKeepPolling(next)) this.stopPolling();\n        if (!ticket || !next.attempt) return;\n\n        // The ticket is exchanged by a normal request, so no session token ever\n        // appears in a URL.\n        const res = await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket,\n        });\n        const kept = res.ok && (await this.reload());\n        this.setState({ ...this.state(), sessionKept: kept });\n        this.stopPolling();\n      })();\n    }, 2_000);\n  }\n\n  private stopPolling(): void {\n    if (this.pollTimer) {\n      clearInterval(this.pollTimer);\n      this.pollTimer = null;\n    }\n  }\n\n  /** Release the poll timer and the captcha widgets — call from the component's `ngOnDestroy`. */\n  destroy(): void {\n    this.stopPolling();\n    this.captcha.destroy();\n    this.signUpCaptcha.destroy();\n  }\n}\n"]}

package/dist/esm2022/lib/components/impersonation-banner.component.mjs

@@ -0,0 +1,75 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Output, computed, inject, signal } from '@angular/core';
+import { actorFromClaims } from '@atlasauth/js';
+import { AtlasService } from '../atlas.service';
+import { classFor } from '../appearance';
+import { translate } from '../i18n';
+import * as i0 from "@angular/core";
+/**
+ * `<atlas-impersonation-banner>` — shown only while the active session is an
+ * impersonation, naming the user acted as, with "Return to admin" (or "End
+ * impersonation" when there is no session of the impersonator's to resume).
+ * Emits `ended` with the outcome. The Angular peer of React's
+ * `<ImpersonationBanner/>`.
+ */
+export class ImpersonationBannerComponent {
+    atlas = inject(AtlasService);
+    ended = new EventEmitter();
+    busy = signal(false);
+    actor = computed(() => actorFromClaims(this.atlas.claims()) ?? this.atlas.session()?.actor ?? null);
+    canReturn = computed(() => this.actor() !== null && Boolean(this.atlas.session()?.actor_session_id));
+    name = computed(() => {
+        const u = this.atlas.user();
+        return ([u?.first_name, u?.last_name].filter(Boolean).join(' ') ||
+            u?.username ||
+            u?.email_addresses?.find((e) => e.primary)?.email_address ||
+            u?.id ||
+            '');
+    });
+    t(key, vars) {
+        return translate(this.atlas.localization, key, vars);
+    }
+    cls(key, base) {
+        return classFor(key, this.atlas.appearance, base);
+    }
+    async end() {
+        this.busy.set(true);
+        try {
+            this.ended.emit(await this.atlas.endImpersonation());
+        }
+        finally {
+            this.busy.set(false);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImpersonationBannerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: ImpersonationBannerComponent, isStandalone: true, selector: "atlas-impersonation-banner", outputs: { ended: "ended" }, ngImport: i0, template: `
+    @if (actor()) {
+      <div [class]="cls('card', 'atlas-alert atlas-impersonation-banner')" role="status">
+        <span [class]="cls('headerSubtitle', 'atlas-text')">{{ t('impersonation.banner', { name: name() }) }}</span>
+        <button type="button" [class]="cls('formButtonPrimary', 'atlas-button')" [disabled]="busy()" (click)="end()">
+          {{ canReturn() ? t('impersonation.returnToAdmin') : t('impersonation.end') }}
+        </button>
+      </div>
+    }
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImpersonationBannerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'atlas-impersonation-banner',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    @if (actor()) {
+      <div [class]="cls('card', 'atlas-alert atlas-impersonation-banner')" role="status">
+        <span [class]="cls('headerSubtitle', 'atlas-text')">{{ t('impersonation.banner', { name: name() }) }}</span>
+        <button type="button" [class]="cls('formButtonPrimary', 'atlas-button')" [disabled]="busy()" (click)="end()">
+          {{ canReturn() ? t('impersonation.returnToAdmin') : t('impersonation.end') }}
+        </button>
+      </div>
+    }
+  `,
+                }]
+        }], propDecorators: { ended: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/components/organization-audit-log.component.mjs

@@ -0,0 +1,115 @@
+import { ChangeDetectionStrategy, Component, Input, inject, } from '@angular/core';
+import { describeAuditAction } from '@atlasauth/js';
+import { AtlasService } from '../atlas.service';
+import { classFor } from '../appearance';
+import * as i0 from "@angular/core";
+/**
+ * `<atlas-organization-audit-log>` — the active organization's audit trail for
+ * its admins, next to `<atlas-organization-profile>`. The Angular peer of
+ * React's `<OrganizationAuditLog/>`. Renders nothing for a member who may not
+ * read it (the server is the authority; the component just follows it). Labels
+ * are inputs so an app can localise them.
+ */
+export class OrganizationAuditLogComponent {
+    /** Entries per page (the server caps it). */
+    pageSize;
+    /** Narrow to one action, or a prefix ending in `.`. */
+    action;
+    labels = {};
+    formatDate = (ms) => new Date(ms).toLocaleString();
+    atlas = inject(AtlasService);
+    /** Created in ngOnInit, once the inputs are set (templates render after it). */
+    log;
+    ngOnInit() {
+        this.log = this.atlas.organizationAuditLog({ pageSize: this.pageSize, action: this.action });
+    }
+    ngOnDestroy() {
+        this.log.destroy();
+    }
+    describe(action) {
+        return describeAuditAction(action);
+    }
+    cls(key, base) {
+        return classFor(key, this.atlas.appearance, base);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OrganizationAuditLogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: OrganizationAuditLogComponent, isStandalone: true, selector: "atlas-organization-audit-log", inputs: { pageSize: "pageSize", action: "action", labels: "labels", formatDate: "formatDate" }, ngImport: i0, template: `
+    @if (atlas.organization() && !log.state().forbidden) {
+      <div [class]="cls('card', 'atlas-card')" data-atlas="organization-audit-log">
+        <h2 [class]="cls('headerTitle', 'atlas-title')">{{ labels.title ?? 'Audit log' }}</h2>
+        @if (log.state().entries.length === 0 && !log.state().loading) {
+          <p [class]="cls('headerSubtitle', 'atlas-subtitle')">{{ labels.empty ?? 'No activity recorded yet.' }}</p>
+        } @else {
+          <ul [class]="cls('list', 'atlas-audit-list')">
+            @for (entry of log.state().entries; track entry.id) {
+              <li [class]="cls('listItem', 'atlas-audit-item')" [attr.data-action]="entry.action">
+                <strong>{{ describe(entry.action) }}</strong>
+                <span class="atlas-audit-meta">
+                  · {{ formatDate(entry.created_at) }}{{ entry.actor.id ? ' · ' + (labels.actor ?? 'by') + ' ' + entry.actor.type + ' ' + entry.actor.id : '' }}
+                </span>
+              </li>
+            }
+          </ul>
+        }
+        @if (log.state().hasMore) {
+          <button
+            type="button"
+            [class]="cls('formButtonSecondary', 'atlas-button-secondary')"
+            [disabled]="log.state().loading"
+            (click)="log.loadMore()"
+          >
+            {{ labels.loadMore ?? 'Load more' }}
+          </button>
+        }
+      </div>
+    }
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OrganizationAuditLogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'atlas-organization-audit-log',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    @if (atlas.organization() && !log.state().forbidden) {
+      <div [class]="cls('card', 'atlas-card')" data-atlas="organization-audit-log">
+        <h2 [class]="cls('headerTitle', 'atlas-title')">{{ labels.title ?? 'Audit log' }}</h2>
+        @if (log.state().entries.length === 0 && !log.state().loading) {
+          <p [class]="cls('headerSubtitle', 'atlas-subtitle')">{{ labels.empty ?? 'No activity recorded yet.' }}</p>
+        } @else {
+          <ul [class]="cls('list', 'atlas-audit-list')">
+            @for (entry of log.state().entries; track entry.id) {
+              <li [class]="cls('listItem', 'atlas-audit-item')" [attr.data-action]="entry.action">
+                <strong>{{ describe(entry.action) }}</strong>
+                <span class="atlas-audit-meta">
+                  · {{ formatDate(entry.created_at) }}{{ entry.actor.id ? ' · ' + (labels.actor ?? 'by') + ' ' + entry.actor.type + ' ' + entry.actor.id : '' }}
+                </span>
+              </li>
+            }
+          </ul>
+        }
+        @if (log.state().hasMore) {
+          <button
+            type="button"
+            [class]="cls('formButtonSecondary', 'atlas-button-secondary')"
+            [disabled]="log.state().loading"
+            (click)="log.loadMore()"
+          >
+            {{ labels.loadMore ?? 'Load more' }}
+          </button>
+        }
+      </div>
+    }
+  `,
+                }]
+        }], propDecorators: { pageSize: [{
+                type: Input
+            }], action: [{
+                type: Input
+            }], labels: [{
+                type: Input
+            }], formatDate: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/components/organization-audit-log.mjs

@@ -0,0 +1,40 @@
+import { signal } from '@angular/core';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { createOrganizationAuditLog, } from '@atlasauth/js';
+/**
+ * The active organization's audit trail, for its admins — the engine behind
+ * `<atlas-organization-audit-log>` and `AtlasService.organizationAuditLog()`
+ * (the Angular peer of React's `useOrganizationAuditLog`). `state` is a signal
+ * of `{ entries, loading, forbidden, hasMore }`, one page at a time, newest
+ * first. It follows the active organization until {@link destroy}.
+ */
+export class AtlasOrganizationAuditLog {
+    _state;
+    log;
+    unsubscribe;
+    organizationSub;
+    state;
+    constructor(client, organization$, options = {}) {
+        this.log = createOrganizationAuditLog(client, options);
+        this._state = signal(this.log.getState());
+        this.state = this._state.asReadonly();
+        this.unsubscribe = this.log.subscribe((next) => this._state.set(next));
+        this.organizationSub = organization$
+            .pipe(map((membership) => membership?.organization.id ?? null), distinctUntilChanged())
+            .subscribe((id) => void this.log.load(id));
+    }
+    /** Append the next page, when there is one. */
+    loadMore() {
+        return this.log.loadMore();
+    }
+    /** Re-read from the newest entry. */
+    reload() {
+        return this.log.reload();
+    }
+    /** Stop following the active organization. */
+    destroy() {
+        this.organizationSub.unsubscribe();
+        this.unsubscribe();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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