@atlasauth/angular 0.2.0 → 0.3.0

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

@@ -1,5 +1,6 @@
 import { signal } from '@angular/core';
-import { advance, flowFromPending, initialFlow, pollAttempt, shouldKeepPolling, } from '@atlasauth/js';
+import { advanceWithCaptcha, createCaptchaController, createSignUp, fetchInstanceSettings, flowNeedsCaptcha, signInCaptchaOptions, flowFromPending, initialFlow, pollAttempt, shouldKeepPolling, } from '@atlasauth/js';
+import { EN_US, translate } from '../i18n';
 /**
  * The server-driven sign-in / sign-up engine, shared by `<atlas-sign-in>` and
  * `<atlas-sign-up>` — the Angular counterpart of React's `useFlow` hook.
@@ -8,18 +9,68 @@ import { advance, flowFromPending, initialFlow, pollAttempt, shouldKeepPolling,
  * server via `advance`, and this controller only posts whatever the current step
  * needs and re-renders the returned status. State lives in a signal so templates
  * update whether the app runs zoned or zoneless.
+ *
+ * `<atlas-sign-up>` starts the attempt with {@link create}
+ * (`POST /v1/client/sign_ups`); the emailed-code step then runs through the same
+ * {@link submit}. Both flows draw the instance's captcha (from
+ * {@link loadSettings}) when it is required.
  */
 export class AtlasFlowController {
     client;
     reload;
+    t;
     state;
+    /**
+     * The instance's public sign-in / sign-up settings (captcha, sign-up fields,
+     * legal consent) from `GET /v1/appearance`; null until {@link loadSettings}
+     * resolves, or when the server could not be reached.
+     */
+    settings = signal(null);
+    /** The sign-in captcha (identifier step / `needs_captcha` challenge). */
+    captcha = createCaptchaController();
+    /** The sign-up captcha (the create-account step). */
+    signUpCaptcha = createCaptchaController();
+    /** Whether {@link captcha} currently draws a widget (for templates). */
+    captchaDrawn = signal(false);
+    /** Whether {@link signUpCaptcha} currently draws a widget (for templates). */
+    signUpCaptchaDrawn = signal(false);
     pollTimer = null;
-    constructor(client, reload, pending) {
+    identifier = '';
+    constructor(client, reload, pending, 
+    /** Resolves the captcha messages' catalog keys. Defaults to en-US. */
+    t = (key) => translate(EN_US, key)) {
         this.client = client;
         this.reload = reload;
+        this.t = t;
         // 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.syncCaptcha();
+    }
+    /** Fetch the instance's public settings and draw whatever captcha they require. */
+    async loadSettings() {
+        const loaded = await fetchInstanceSettings(this.client);
+        if (loaded) {
+            this.settings.set(loaded);
+            this.syncCaptcha();
+        }
+    }
+    /** Keep both captchas in step with the settings and the flow's current step. */
+    syncCaptcha() {
+        const settings = this.settings();
+        const state = this.state();
+        this.captcha.configure(signInCaptchaOptions(settings?.captchaFlows.signIn, state, () => void this.submit({})));
+        const signUpFlow = settings?.captchaFlows.signUp;
+        this.signUpCaptcha.configure({
+            flow: signUpFlow,
+            active: !state.attempt && flowNeedsCaptcha(signUpFlow),
+        });
+        this.captchaDrawn.set(this.captcha.needed);
+        this.signUpCaptchaDrawn.set(this.signUpCaptcha.needed);
+    }
+    setState(next) {
+        this.state.set(next);
+        this.syncCaptcha();
     }
     /**
      * Advance the flow with the values the user typed. On completion, exchange the
@@ -29,8 +80,31 @@ export class AtlasFlowController {
      */
     async submit(values) {
         this.state.update((current) => ({ ...current, busy: true, errors: [] }));
-        const next = await advance(this.client, this.state(), values);
-        this.state.set(next);
+        const out = await advanceWithCaptcha(this.client, this.state(), values, {
+            captcha: this.captcha,
+            identifier: this.identifier,
+            t: this.t,
+        });
+        this.identifier = out.identifier;
+        await this.finish(out.state);
+    }
+    /**
+     * Create an account (`POST /v1/client/sign_ups`) from a create-account form's
+     * values — email, password and any configured sign-up fields — carrying the
+     * sign-up captcha's token when the instance requires one. The emailed code is
+     * then posted with {@link submit}.
+     */
+    async create(values, consent = true) {
+        this.state.update((current) => ({ ...current, busy: true, errors: [] }));
+        const next = await createSignUp(this.client, values, {
+            consent,
+            captcha: this.signUpCaptcha,
+            t: this.t,
+        });
+        await this.finish(next);
+    }
+    async finish(next) {
+        this.setState(next);
         if (next.attempt?.status === 'complete') {
             if (next.ticket) {
                 await this.client.post('/v1/client/tickets/exchange', {
@@ -60,7 +134,7 @@ export class AtlasFlowController {
         this.pollTimer = setInterval(() => {
             void (async () => {
                 const { state: next, ticket } = await pollAttempt(this.client, this.state());
-                this.state.set(next);
+                this.setState(next);
                 if (!ticket || !next.attempt)
                     return;
                 // The ticket is exchanged by a normal request, so no session token ever
@@ -80,9 +154,11 @@ export class AtlasFlowController {
             this.pollTimer = null;
         }
     }
-    /** Release the poll timer — call from the component's `ngOnDestroy`. */
+    /** Release the poll timer and the captcha widgets — call from the component's `ngOnDestroy`. */
     destroy() {
         this.stopPolling();
+        this.captcha.destroy();
+        this.signUpCaptcha.destroy();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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  createCaptchaController,\n  createSignUp,\n  fetchInstanceSettings,\n  flowNeedsCaptcha,\n  signInCaptchaOptions,\n  flowFromPending,\n  initialFlow,\n  pollAttempt,\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();\n  /** The sign-up captcha (the create-account step). */\n  readonly signUpCaptcha: CaptchaController = createCaptchaController();\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  private pollTimer: ReturnType<typeof setInterval> | null = null;\n  private identifier = '';\n\n  constructor(\n    private readonly client: FapiClient,\n    private readonly reload: () => Promise<void>,\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  /** 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    this.syncCaptcha();\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    this.setState(next);\n\n    if (next.attempt?.status === 'complete') {\n      if (next.ticket) {\n        await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket: next.ticket,\n        });\n      }\n      await this.reload();\n    } else {\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        await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket,\n        });\n        await this.reload();\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/sign-in.component.mjs

@@ -1,11 +1,14 @@
 import { ChangeDetectionStrategy, Component, Input, inject, } from '@angular/core';
 import { AtlasService } from '../atlas.service';
+import { translate } from '../i18n';
 import { AttemptFlowComponent } from './attempt-flow.component';
 import { AtlasFlowController } from './flow-controller';
 import * as i0 from "@angular/core";
 /**
  * `<atlas-sign-in>` — the full, multi-step sign-in flow driven entirely by the
- * server-side attempt status. The Angular peer of React's `<SignIn/>`.
+ * server-side attempt status. The Angular peer of React's `<SignIn/>`. Draws the
+ * instance's sign-in captcha when it is required (always-on, or a
+ * `needs_captcha` challenge).
  *
  * ```html
  * <atlas-sign-in *atlasSignedOut afterUrl="/dashboard"></atlas-sign-in>
@@ -17,10 +20,14 @@ export class SignInComponent {
     afterUrl;
     flow = new AtlasFlowController(this.atlas.createFapiClient(), () => this.atlas.reload(), 
     // Resume mid-flow if an OAuth redirect came back owing a second factor.
-    this.atlas.pendingAttempt);
+    this.atlas.pendingAttempt, (key) => translate(this.atlas.localization, key));
     ngOnInit() {
         // If seeded from a pending attempt that is already pollable, start polling.
         this.flow.syncPolling();
+        // §5 the instance's captcha settings: switching captcha on in the dashboard
+        // draws it here with no code change.
+        if (typeof window !== 'undefined')
+            void this.flow.loadSettings();
     }
     ngOnDestroy() {
         this.flow.destroy();
@@ -32,9 +39,10 @@ export class SignInComponent {
       [busy]="flow.state().busy"
       [errors]="flow.state().errors"
       titleKey="signIn.title"
+      [captcha]="flow.captchaDrawn() ? flow.captcha : null"
       (submitFlow)="flow.submit($event)"
     ></atlas-attempt-flow>
-  `, isInline: true, dependencies: [{ kind: "component", type: AttemptFlowComponent, selector: "atlas-attempt-flow", inputs: ["attempt", "busy", "errors", "titleKey"], outputs: ["submitFlow"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, dependencies: [{ kind: "component", type: AttemptFlowComponent, selector: "atlas-attempt-flow", inputs: ["attempt", "busy", "errors", "titleKey", "captcha"], outputs: ["submitFlow"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignInComponent, decorators: [{
             type: Component,
@@ -49,6 +57,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
       [busy]="flow.state().busy"
       [errors]="flow.state().errors"
       titleKey="signIn.title"
+      [captcha]="flow.captchaDrawn() ? flow.captcha : null"
       (submitFlow)="flow.submit($event)"
     ></atlas-attempt-flow>
   `,
@@ -56,4 +65,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
         }], propDecorators: { afterUrl: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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