@atlasauth/angular 0.8.0 → 0.10.0

package/dist/esm2022/lib/components/policy-host.mjs

@@ -0,0 +1,254 @@
+import { ChangeDetectionStrategy, Component, Directive, ElementRef, EventEmitter, Input, Output, inject, signal, } from '@angular/core';
+import { PolicyGateController, controllerForPending, formatPolicyDate, injectPolicyStyles, joinTitles, mountPolicyAcceptStep, mountPolicyClickwrap, mountPolicyConsent, policyTranslator, } from '@atlasauth/js';
+import { AtlasService } from '../atlas.service';
+import { classFor } from '../appearance';
+import { translate } from '../i18n';
+import * as i0 from "@angular/core";
+/** The policy UI's translator (the localization bundle, else the English policy strings) for the current Atlas service. */
+export function policyUi(atlas) {
+    return {
+        t: policyTranslator((key, vars) => translate(atlas.localization, key, vars)),
+        classes: {
+            link: 'atlas-link',
+            text: 'atlas-text',
+            primaryButton: classFor('formButtonPrimary', atlas.appearance, 'atlas-button'),
+            error: classFor('formFieldError', atlas.appearance, 'atlas-error'),
+        },
+    };
+}
+/**
+ * `[atlasPolicies]="controller"` — draws the instance's policies (terms, privacy,
+ * …) into the host element: `kind="consent"` (default) is the checkbox block with
+ * its in-page viewer, `kind="clickwrap"` the "By continuing you agree to …" line.
+ * The state is the controller's (`AtlasFlowController.policies`); the DOM comes
+ * from `@atlasauth/js`, shared with every SDK.
+ */
+export class AtlasPoliciesDirective {
+    host = inject(ElementRef);
+    atlas = inject(AtlasService);
+    mounted = null;
+    ready = false;
+    controller = null;
+    atlasPolicyKind = 'consent';
+    ngOnInit() {
+        this.ready = true;
+        this.draw();
+    }
+    ngOnChanges(changes) {
+        if (this.ready && (changes['controller'] || changes['atlasPolicyKind']))
+            this.draw();
+    }
+    ngOnDestroy() {
+        this.mounted?.destroy();
+    }
+    draw() {
+        this.mounted?.destroy();
+        this.mounted = null;
+        if (!this.controller)
+            return;
+        const el = this.host.nativeElement;
+        injectPolicyStyles(el.ownerDocument);
+        const ui = policyUi(this.atlas);
+        this.mounted =
+            this.atlasPolicyKind === 'clickwrap'
+                ? mountPolicyClickwrap(el, this.controller, ui)
+                : mountPolicyConsent(el, this.controller, ui);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasPoliciesDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AtlasPoliciesDirective, isStandalone: true, selector: "[atlasPolicies]", inputs: { controller: ["atlasPolicies", "controller"], atlasPolicyKind: "atlasPolicyKind" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasPoliciesDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[atlasPolicies]', standalone: true }]
+        }], propDecorators: { controller: [{
+                type: Input,
+                args: ['atlasPolicies']
+            }], atlasPolicyKind: [{
+                type: Input
+            }] } });
+/**
+ * `<atlas-policy-accept-step>` — the sign-in step for a `needs_policy_acceptance`
+ * attempt: scroll-mode policies in their unskippable dialog, the rest as
+ * checkboxes, then "Accept and continue". Emits `submitFlow` with the
+ * `policy_acceptances` JSON for the flow, and `declined` with the policy title
+ * when the user declines (cancel the attempt).
+ */
+export class PolicyAcceptStepComponent {
+    host = inject(ElementRef);
+    atlas = inject(AtlasService);
+    step = null;
+    alive = true;
+    attempt = null;
+    busy = false;
+    submitFlow = new EventEmitter();
+    declined = new EventEmitter();
+    loading = signal(true);
+    loadingText = policyUi(this.atlas).t('policy.loading');
+    ngOnInit() {
+        const client = this.atlas.createFapiClient();
+        void controllerForPending(client, this.attempt, { locale: this.atlas.locale ?? undefined }).then((controller) => {
+            if (!this.alive)
+                return;
+            this.loading.set(false);
+            const el = this.host.nativeElement.querySelector('.atlas-policy-step-host');
+            if (!el)
+                return;
+            injectPolicyStyles(el.ownerDocument);
+            this.step = mountPolicyAcceptStep(el, controller, {
+                ...policyUi(this.atlas),
+                onSubmit: (acceptances) => this.submitFlow.emit({ policy_acceptances: JSON.stringify(acceptances) }),
+                onDecline: (policy) => this.declined.emit(policy.title),
+            });
+            this.step.setBusy(this.busy);
+        });
+    }
+    ngOnChanges(changes) {
+        if (changes['busy'])
+            this.step?.setBusy(this.busy);
+    }
+    ngOnDestroy() {
+        this.alive = false;
+        this.step?.destroy();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PolicyAcceptStepComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: PolicyAcceptStepComponent, isStandalone: true, selector: "atlas-policy-accept-step", inputs: { attempt: "attempt", busy: "busy" }, outputs: { submitFlow: "submitFlow", declined: "declined" }, usesOnChanges: true, ngImport: i0, template: `@if (loading()) {<p class="atlas-text">{{ loadingText }}</p>}<div class="atlas-policy-step-host"></div>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PolicyAcceptStepComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'atlas-policy-accept-step',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `@if (loading()) {<p class="atlas-text">{{ loadingText }}</p>}<div class="atlas-policy-step-host"></div>`,
+                }]
+        }], propDecorators: { attempt: [{
+                type: Input
+            }], busy: [{
+                type: Input
+            }], submitFlow: [{
+                type: Output
+            }], declined: [{
+                type: Output
+            }] } });
+/**
+ * `<atlas-policy-gate>` — in-app re-acceptance. For a signed-in user, a banner
+ * when a policy needs re-acceptance; "Review and accept" opens the unskippable
+ * dialog / checkboxes and posts `/v1/client/me/policies/accept`. Projects its
+ * content always.
+ */
+export class PolicyGateComponent {
+    host = inject(ElementRef);
+    atlas = inject(AtlasService);
+    ui = policyUi(this.atlas);
+    gate;
+    off = null;
+    step = null;
+    version = signal(0);
+    accepted = new EventEmitter();
+    reviewing = signal(false);
+    error = signal('');
+    title = this.ui.t('policy.bannerTitle');
+    reviewText = this.ui.t('policy.bannerReview');
+    linkClass = this.ui.classes.link ?? '';
+    errorClass = this.ui.classes.error ?? '';
+    bannerClass = 'atlas-policy-banner';
+    cardClass = classFor('card', this.atlas.appearance, 'atlas-card');
+    bannerText() {
+        this.version();
+        if (!this.gate || this.gate.pending.length === 0 || this.reviewing())
+            return null;
+        const t = this.ui.t;
+        const grace = this.gate.graceEndsAt;
+        return (t('policy.bannerBody', { policies: joinTitles(this.gate.pending.map((p) => p.title), t('policy.and')) }) +
+            (grace ? ` ${t('policy.bannerGrace', { date: formatPolicyDate(grace) })}` : ''));
+    }
+    ngOnInit() {
+        this.gate = new PolicyGateController(this.atlas.createFapiClient(), this.atlas.locale ?? undefined);
+        this.off = this.gate.subscribe(() => this.version.update((n) => n + 1));
+        if (this.atlas.status() === 'signed_in')
+            void this.gate.load();
+    }
+    async begin() {
+        const controller = await this.gate.begin();
+        this.reviewing.set(true);
+        await Promise.resolve();
+        const el = this.host.nativeElement.querySelector('.atlas-policy-gate-host');
+        if (!el)
+            return;
+        injectPolicyStyles(el.ownerDocument);
+        this.step = mountPolicyAcceptStep(el, controller, {
+            ...this.ui,
+            onSubmit: async () => {
+                this.step?.setBusy(true);
+                const res = await this.gate.accept(controller);
+                this.step?.setBusy(false);
+                if (!res.ok) {
+                    this.error.set(res.errors[0]?.message ?? this.ui.t('policy.requiredGeneric'));
+                    return;
+                }
+                this.close();
+                this.accepted.emit();
+            },
+            onDecline: () => this.close(),
+        });
+    }
+    close() {
+        this.step?.destroy();
+        this.step = null;
+        this.reviewing.set(false);
+    }
+    ngOnDestroy() {
+        this.off?.();
+        this.step?.destroy();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PolicyGateComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: PolicyGateComponent, isStandalone: true, selector: "atlas-policy-gate", outputs: { accepted: "accepted" }, ngImport: i0, template: `
+    @if (bannerText(); as text) {
+      <div [class]="bannerClass" role="status" data-atlas-policy-banner="">
+        <span
+          ><strong>{{ title }}. </strong>{{ text }}</span
+        >
+        <button type="button" [class]="linkClass" (click)="begin()">{{ reviewText }}</button>
+      </div>
+    }
+    @if (reviewing()) {
+      <div [class]="cardClass" data-atlas-policy-gate="">
+        <div class="atlas-policy-gate-host"></div>
+        @if (error()) {
+          <p [class]="errorClass" role="alert">{{ error() }}</p>
+        }
+      </div>
+    }
+    <ng-content></ng-content>
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PolicyGateComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'atlas-policy-gate',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    @if (bannerText(); as text) {
+      <div [class]="bannerClass" role="status" data-atlas-policy-banner="">
+        <span
+          ><strong>{{ title }}. </strong>{{ text }}</span
+        >
+        <button type="button" [class]="linkClass" (click)="begin()">{{ reviewText }}</button>
+      </div>
+    }
+    @if (reviewing()) {
+      <div [class]="cardClass" data-atlas-policy-gate="">
+        <div class="atlas-policy-gate-host"></div>
+        @if (error()) {
+          <p [class]="errorClass" role="alert">{{ error() }}</p>
+        }
+      </div>
+    }
+    <ng-content></ng-content>
+  `,
+                }]
+        }], propDecorators: { accepted: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-host.js","sourceRoot":"","sources":["../../../../src/lib/components/policy-host.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  inject,\n  signal,\n  type SimpleChanges,\n} from '@angular/core';\nimport {\n  PolicyGateController,\n  controllerForPending,\n  formatPolicyDate,\n  injectPolicyStyles,\n  joinTitles,\n  mountPolicyAcceptStep,\n  mountPolicyClickwrap,\n  mountPolicyConsent,\n  policyTranslator,\n  type MountedPolicyStep,\n  type MountedPolicyUi,\n  type Policy,\n  type PolicyAcceptanceController,\n  type PolicyClasses,\n  type PolicyT,\n} from '@atlasauth/js';\nimport { AtlasService } from '../atlas.service';\nimport { classFor } from '../appearance';\nimport { translate } from '../i18n';\n\n/** The policy UI's translator (the localization bundle, else the English policy strings) for the current Atlas service. */\nexport function policyUi(atlas: AtlasService): { t: PolicyT; classes: PolicyClasses } {\n  return {\n    t: policyTranslator((key, vars) => translate(atlas.localization, key, vars)),\n    classes: {\n      link: 'atlas-link',\n      text: 'atlas-text',\n      primaryButton: classFor('formButtonPrimary', atlas.appearance, 'atlas-button'),\n      error: classFor('formFieldError', atlas.appearance, 'atlas-error'),\n    },\n  };\n}\n\n/**\n * `[atlasPolicies]=\"controller\"` — draws the instance's policies (terms, privacy,\n * …) into the host element: `kind=\"consent\"` (default) is the checkbox block with\n * its in-page viewer, `kind=\"clickwrap\"` the \"By continuing you agree to …\" line.\n * The state is the controller's (`AtlasFlowController.policies`); the DOM comes\n * from `@atlasauth/js`, shared with every SDK.\n */\n@Directive({ selector: '[atlasPolicies]', standalone: true })\nexport class AtlasPoliciesDirective implements OnInit, OnChanges, OnDestroy {\n  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly atlas = inject(AtlasService);\n  private mounted: MountedPolicyUi | null = null;\n  private ready = false;\n\n  @Input('atlasPolicies') controller: PolicyAcceptanceController | null = null;\n  @Input() atlasPolicyKind: 'consent' | 'clickwrap' = 'consent';\n\n  ngOnInit(): void {\n    this.ready = true;\n    this.draw();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (this.ready && (changes['controller'] || changes['atlasPolicyKind'])) this.draw();\n  }\n\n  ngOnDestroy(): void {\n    this.mounted?.destroy();\n  }\n\n  private draw(): void {\n    this.mounted?.destroy();\n    this.mounted = null;\n    if (!this.controller) return;\n    const el = this.host.nativeElement;\n    injectPolicyStyles(el.ownerDocument);\n    const ui = policyUi(this.atlas);\n    this.mounted =\n      this.atlasPolicyKind === 'clickwrap'\n        ? mountPolicyClickwrap(el, this.controller, ui)\n        : mountPolicyConsent(el, this.controller, ui);\n  }\n}\n\n/**\n * `<atlas-policy-accept-step>` — the sign-in step for a `needs_policy_acceptance`\n * attempt: scroll-mode policies in their unskippable dialog, the rest as\n * checkboxes, then \"Accept and continue\". Emits `submitFlow` with the\n * `policy_acceptances` JSON for the flow, and `declined` with the policy title\n * when the user declines (cancel the attempt).\n */\n@Component({\n  selector: 'atlas-policy-accept-step',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `@if (loading()) {<p class=\"atlas-text\">{{ loadingText }}</p>}<div class=\"atlas-policy-step-host\"></div>`,\n})\nexport class PolicyAcceptStepComponent implements OnInit, OnChanges, OnDestroy {\n  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly atlas = inject(AtlasService);\n  private step: MountedPolicyStep | null = null;\n  private alive = true;\n\n  @Input() attempt: { id: string | null; pending_policies?: unknown } | null = null;\n  @Input() busy = false;\n  @Output() submitFlow = new EventEmitter<Record<string, string>>();\n  @Output() declined = new EventEmitter<string>();\n\n  protected readonly loading = signal(true);\n  protected loadingText = policyUi(this.atlas).t('policy.loading');\n\n  ngOnInit(): void {\n    const client = this.atlas.createFapiClient();\n    void controllerForPending(client, this.attempt, { locale: this.atlas.locale ?? undefined }).then((controller) => {\n      if (!this.alive) return;\n      this.loading.set(false);\n      const el = this.host.nativeElement.querySelector('.atlas-policy-step-host') as HTMLElement | null;\n      if (!el) return;\n      injectPolicyStyles(el.ownerDocument);\n      this.step = mountPolicyAcceptStep(el, controller, {\n        ...policyUi(this.atlas),\n        onSubmit: (acceptances) => this.submitFlow.emit({ policy_acceptances: JSON.stringify(acceptances) }),\n        onDecline: (policy: Policy) => this.declined.emit(policy.title),\n      });\n      this.step.setBusy(this.busy);\n    });\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['busy']) this.step?.setBusy(this.busy);\n  }\n\n  ngOnDestroy(): void {\n    this.alive = false;\n    this.step?.destroy();\n  }\n}\n\n/**\n * `<atlas-policy-gate>` — in-app re-acceptance. For a signed-in user, a banner\n * when a policy needs re-acceptance; \"Review and accept\" opens the unskippable\n * dialog / checkboxes and posts `/v1/client/me/policies/accept`. Projects its\n * content always.\n */\n@Component({\n  selector: 'atlas-policy-gate',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    @if (bannerText(); as text) {\n      <div [class]=\"bannerClass\" role=\"status\" data-atlas-policy-banner=\"\">\n        <span\n          ><strong>{{ title }}. </strong>{{ text }}</span\n        >\n        <button type=\"button\" [class]=\"linkClass\" (click)=\"begin()\">{{ reviewText }}</button>\n      </div>\n    }\n    @if (reviewing()) {\n      <div [class]=\"cardClass\" data-atlas-policy-gate=\"\">\n        <div class=\"atlas-policy-gate-host\"></div>\n        @if (error()) {\n          <p [class]=\"errorClass\" role=\"alert\">{{ error() }}</p>\n        }\n      </div>\n    }\n    <ng-content></ng-content>\n  `,\n})\nexport class PolicyGateComponent implements OnInit, OnDestroy {\n  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly atlas = inject(AtlasService);\n  private readonly ui = policyUi(this.atlas);\n  private gate!: PolicyGateController;\n  private off: (() => void) | null = null;\n  private step: MountedPolicyStep | null = null;\n  private readonly version = signal(0);\n\n  @Output() accepted = new EventEmitter<void>();\n\n  protected readonly reviewing = signal(false);\n  protected readonly error = signal('');\n  protected title = this.ui.t('policy.bannerTitle');\n  protected reviewText = this.ui.t('policy.bannerReview');\n  protected linkClass = this.ui.classes.link ?? '';\n  protected errorClass = this.ui.classes.error ?? '';\n  protected bannerClass = 'atlas-policy-banner';\n  protected cardClass = classFor('card', this.atlas.appearance, 'atlas-card');\n\n  protected bannerText(): string | null {\n    this.version();\n    if (!this.gate || this.gate.pending.length === 0 || this.reviewing()) return null;\n    const t = this.ui.t;\n    const grace = this.gate.graceEndsAt;\n    return (\n      t('policy.bannerBody', { policies: joinTitles(this.gate.pending.map((p) => p.title), t('policy.and')) }) +\n      (grace ? ` ${t('policy.bannerGrace', { date: formatPolicyDate(grace) })}` : '')\n    );\n  }\n\n  ngOnInit(): void {\n    this.gate = new PolicyGateController(this.atlas.createFapiClient(), this.atlas.locale ?? undefined);\n    this.off = this.gate.subscribe(() => this.version.update((n) => n + 1));\n    if (this.atlas.status() === 'signed_in') void this.gate.load();\n  }\n\n  async begin(): Promise<void> {\n    const controller = await this.gate.begin();\n    this.reviewing.set(true);\n    await Promise.resolve();\n    const el = this.host.nativeElement.querySelector('.atlas-policy-gate-host') as HTMLElement | null;\n    if (!el) return;\n    injectPolicyStyles(el.ownerDocument);\n    this.step = mountPolicyAcceptStep(el, controller, {\n      ...this.ui,\n      onSubmit: async () => {\n        this.step?.setBusy(true);\n        const res = await this.gate.accept(controller);\n        this.step?.setBusy(false);\n        if (!res.ok) {\n          this.error.set(res.errors[0]?.message ?? this.ui.t('policy.requiredGeneric'));\n          return;\n        }\n        this.close();\n        this.accepted.emit();\n      },\n      onDecline: () => this.close(),\n    });\n  }\n\n  private close(): void {\n    this.step?.destroy();\n    this.step = null;\n    this.reviewing.set(false);\n  }\n\n  ngOnDestroy(): void {\n    this.off?.();\n    this.step?.destroy();\n  }\n}\n"]}

package/dist/esm2022/lib/components/recovery-codes.component.mjs

@@ -0,0 +1,122 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, Output, inject, } from '@angular/core';
+import { canDownloadRecoveryCodes, copyRecoveryCodes, downloadRecoveryCodes } from '@atlasauth/js';
+import { AtlasService } from '../atlas.service';
+import { classFor } from '../appearance';
+import { translate } from '../i18n';
+import * as i0 from "@angular/core";
+/**
+ * The recovery codes a mid-sign-in MFA enrolment came with, shown once before
+ * the sign-in finishes: copy them, download them as a .txt file, then
+ * "I've saved my codes" (`saved`) exchanges the ticket. The codes live only in
+ * the flow controller's memory and are forgotten once saved.
+ */
+export class RecoveryCodesComponent {
+    atlas = inject(AtlasService);
+    cdr = inject(ChangeDetectorRef);
+    codes = [];
+    busy = false;
+    saved = new EventEmitter();
+    canCopy = typeof navigator !== 'undefined' && !!navigator.clipboard?.writeText;
+    canDownload = canDownloadRecoveryCodes();
+    copied = false;
+    ngOnChanges() {
+        this.copied = false;
+    }
+    t(key) {
+        return translate(this.atlas.localization, key);
+    }
+    cls(key, base) {
+        return classFor(key, this.atlas.appearance, base);
+    }
+    copy() {
+        void copyRecoveryCodes(this.codes).then((ok) => {
+            this.copied = ok;
+            this.cdr.markForCheck();
+        });
+    }
+    download() {
+        downloadRecoveryCodes(this.codes);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RecoveryCodesComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: RecoveryCodesComponent, isStandalone: true, selector: "atlas-recovery-codes", inputs: { codes: "codes", busy: "busy" }, outputs: { saved: "saved" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="cls('card', 'atlas-card')" data-atlas="recovery-codes">
+      <h1 [class]="cls('headerTitle', 'atlas-title')">{{ t('mfa.recoveryCodesTitle') }}</h1>
+      <p class="atlas-text">{{ t('mfa.recoveryCodesHelp') }}</p>
+      <ul
+        class="atlas-recovery-codes"
+        data-atlas="recovery-codes-list"
+        style="list-style:none;padding:0;margin:8px 0 12px;display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:6px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;text-align:center"
+      >
+        @for (code of codes; track code) {
+          <li><code>{{ code }}</code></li>
+        }
+      </ul>
+      <div class="atlas-alternatives">
+        @if (canCopy) {
+          <button [class]="cls('formButtonSecondary', 'atlas-button-secondary')" type="button" data-atlas="recovery-codes-copy" (click)="copy()">
+            {{ t('mfa.recoveryCodesCopy') }}
+          </button>
+        }
+        @if (canDownload) {
+          <button [class]="cls('formButtonSecondary', 'atlas-button-secondary')" type="button" data-atlas="recovery-codes-download" (click)="download()">
+            {{ t('mfa.recoveryCodesDownload') }}
+          </button>
+        }
+      </div>
+      @if (copied) {
+        <p class="atlas-text" aria-live="polite" data-atlas="recovery-codes-copied">{{ t('mfa.recoveryCodesCopied') }}</p>
+      }
+      <button [class]="cls('formButtonPrimary', 'atlas-button')" type="button" data-atlas="recovery-codes-saved" [disabled]="busy" (click)="saved.emit()">
+        {{ t('mfa.recoveryCodesSaved') }}
+      </button>
+    </div>
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RecoveryCodesComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'atlas-recovery-codes',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <div [class]="cls('card', 'atlas-card')" data-atlas="recovery-codes">
+      <h1 [class]="cls('headerTitle', 'atlas-title')">{{ t('mfa.recoveryCodesTitle') }}</h1>
+      <p class="atlas-text">{{ t('mfa.recoveryCodesHelp') }}</p>
+      <ul
+        class="atlas-recovery-codes"
+        data-atlas="recovery-codes-list"
+        style="list-style:none;padding:0;margin:8px 0 12px;display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:6px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;text-align:center"
+      >
+        @for (code of codes; track code) {
+          <li><code>{{ code }}</code></li>
+        }
+      </ul>
+      <div class="atlas-alternatives">
+        @if (canCopy) {
+          <button [class]="cls('formButtonSecondary', 'atlas-button-secondary')" type="button" data-atlas="recovery-codes-copy" (click)="copy()">
+            {{ t('mfa.recoveryCodesCopy') }}
+          </button>
+        }
+        @if (canDownload) {
+          <button [class]="cls('formButtonSecondary', 'atlas-button-secondary')" type="button" data-atlas="recovery-codes-download" (click)="download()">
+            {{ t('mfa.recoveryCodesDownload') }}
+          </button>
+        }
+      </div>
+      @if (copied) {
+        <p class="atlas-text" aria-live="polite" data-atlas="recovery-codes-copied">{{ t('mfa.recoveryCodesCopied') }}</p>
+      }
+      <button [class]="cls('formButtonPrimary', 'atlas-button')" type="button" data-atlas="recovery-codes-saved" [disabled]="busy" (click)="saved.emit()">
+        {{ t('mfa.recoveryCodesSaved') }}
+      </button>
+    </div>
+  `,
+                }]
+        }], propDecorators: { codes: [{
+                type: Input
+            }], busy: [{
+                type: Input
+            }], saved: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/components/sign-in.component.mjs

@@ -1,8 +1,9 @@
 import { ChangeDetectionStrategy, Component, Input, inject, } from '@angular/core';
-import { signUp as hostedSignUp } from '@atlasauth/js';
+import { lastUsedMethodLabel, signUp as hostedSignUp } from '@atlasauth/js';
 import { AtlasService } from '../atlas.service';
 import { translate } from '../i18n';
 import { AttemptFlowComponent } from './attempt-flow.component';
+import { RecoveryCodesComponent } from './recovery-codes.component';
 import { AtlasFlowController } from './flow-controller';
 import * as i0 from "@angular/core";
 /**
@@ -28,6 +29,12 @@ export class SignInComponent {
     t(key) {
         return translate(this.atlas.localization, key);
     }
+    /** "Last used: Password" on the identifier step, when the instance shows the hint. */
+    lastUsedLabel() {
+        if (this.flow.state().attempt)
+            return null;
+        return lastUsedMethodLabel(this.flow.lastMethod(), (key) => this.t(key));
+    }
     signUpHref() {
         if (this.signUpUrl === null)
             return null;
@@ -61,6 +68,14 @@ export class SignInComponent {
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignInComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: SignInComponent, isStandalone: true, selector: "atlas-sign-in", inputs: { afterUrl: "afterUrl", signUpUrl: "signUpUrl" }, ngImport: i0, template: `
+    @if (lastUsedLabel(); as label) {
+      <p class="atlas-text atlas-last-used-hint" data-atlas="last-used" [attr.data-atlas-method]="flow.lastMethod()">
+        {{ t('signIn.lastUsed') }}: {{ label }}
+      </p>
+    }
+    @if (flow.recoveryCodes(); as codes) {
+      <atlas-recovery-codes [codes]="codes" [busy]="flow.state().busy" (saved)="flow.saveRecoveryCodes()"></atlas-recovery-codes>
+    } @else {
     <atlas-attempt-flow
       [attempt]="flow.state().attempt"
       [busy]="flow.state().busy"
@@ -70,15 +85,25 @@ export class SignInComponent {
       [captcha]="flow.captchaDrawn() ? flow.captcha : null"
       [firstFactors]="flow.firstFactors()"
       [preparedFactor]="flow.preparedFactor()"
+      [offerEmailSecondFactor]="flow.settings()?.account?.emailSecondFactor === true"
+      [emailedSecondFactor]="flow.emailSecondFactor()"
       (submitFlow)="flow.submit($event)"
       (chooseFactor)="flow.prepare($event)"
+      [offerSmsSecondFactor]="flow.settings() !== null && flow.mfaChoices().sms"
+      [textedSecondFactor]="flow.smsSecondFactor()"
+      [enrollment]="flow.enrollment"
+      [enrollmentState]="flow.enrollmentState()"
+      (emailSecondFactor)="flow.sendEmailSecondFactor()"
+      (smsSecondFactor)="flow.sendSmsSecondFactor()"
+      (policyDeclined)="flow.declinePolicy($event)"
     ></atlas-attempt-flow>
+    }
     @if (flow.state().attempt?.status !== 'complete' && signUpHref(); as href) {
       <p class="atlas-footer" data-atlas-sign-up-prompt="">
         {{ t('signIn.noAccount') }} <a class="atlas-link" [href]="href">{{ t('signIn.signUpLink') }}</a>
       </p>
     }
-  `, isInline: true, dependencies: [{ kind: "component", type: AttemptFlowComponent, selector: "atlas-attempt-flow", inputs: ["attempt", "busy", "errors", "sessionKept", "titleKey", "captcha", "firstFactors", "preparedFactor"], outputs: ["submitFlow", "chooseFactor"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, dependencies: [{ kind: "component", type: AttemptFlowComponent, selector: "atlas-attempt-flow", inputs: ["attempt", "busy", "errors", "sessionKept", "titleKey", "captcha", "firstFactors", "preparedFactor", "offerEmailSecondFactor", "emailedSecondFactor", "offerSmsSecondFactor", "textedSecondFactor", "enrollment", "enrollmentState", "emailVerification"], outputs: ["submitFlow", "chooseFactor", "emailSecondFactor", "smsSecondFactor", "resend", "policyDeclined"] }, { kind: "component", type: RecoveryCodesComponent, selector: "atlas-recovery-codes", inputs: ["codes", "busy"], outputs: ["saved"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignInComponent, decorators: [{
             type: Component,
@@ -86,8 +111,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     selector: 'atlas-sign-in',
                     standalone: true,
                     changeDetection: ChangeDetectionStrategy.OnPush,
-                    imports: [AttemptFlowComponent],
+                    imports: [AttemptFlowComponent, RecoveryCodesComponent],
                     template: `
+    @if (lastUsedLabel(); as label) {
+      <p class="atlas-text atlas-last-used-hint" data-atlas="last-used" [attr.data-atlas-method]="flow.lastMethod()">
+        {{ t('signIn.lastUsed') }}: {{ label }}
+      </p>
+    }
+    @if (flow.recoveryCodes(); as codes) {
+      <atlas-recovery-codes [codes]="codes" [busy]="flow.state().busy" (saved)="flow.saveRecoveryCodes()"></atlas-recovery-codes>
+    } @else {
     <atlas-attempt-flow
       [attempt]="flow.state().attempt"
       [busy]="flow.state().busy"
@@ -97,9 +130,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
       [captcha]="flow.captchaDrawn() ? flow.captcha : null"
       [firstFactors]="flow.firstFactors()"
       [preparedFactor]="flow.preparedFactor()"
+      [offerEmailSecondFactor]="flow.settings()?.account?.emailSecondFactor === true"
+      [emailedSecondFactor]="flow.emailSecondFactor()"
       (submitFlow)="flow.submit($event)"
       (chooseFactor)="flow.prepare($event)"
+      [offerSmsSecondFactor]="flow.settings() !== null && flow.mfaChoices().sms"
+      [textedSecondFactor]="flow.smsSecondFactor()"
+      [enrollment]="flow.enrollment"
+      [enrollmentState]="flow.enrollmentState()"
+      (emailSecondFactor)="flow.sendEmailSecondFactor()"
+      (smsSecondFactor)="flow.sendSmsSecondFactor()"
+      (policyDeclined)="flow.declinePolicy($event)"
     ></atlas-attempt-flow>
+    }
     @if (flow.state().attempt?.status !== 'complete' && signUpHref(); as href) {
       <p class="atlas-footer" data-atlas-sign-up-prompt="">
         {{ t('signIn.noAccount') }} <a class="atlas-link" [href]="href">{{ t('signIn.signUpLink') }}</a>
@@ -112,4 +155,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             }], signUpUrl: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign-in.component.js","sourceRoot":"","sources":["../../../../src/lib/components/sign-in.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  Input,\n  OnDestroy,\n  OnInit,\n  inject,\n} from '@angular/core';\nimport { lastUsedMethodLabel, signUp as hostedSignUp } from '@atlasauth/js';\nimport { AtlasService } from '../atlas.service';\nimport { translate } from '../i18n';\nimport { AttemptFlowComponent } from './attempt-flow.component';\nimport { RecoveryCodesComponent } from './recovery-codes.component';\nimport { AtlasFlowController } from './flow-controller';\n\n/**\n * `<atlas-sign-in>` — the full, multi-step sign-in flow driven entirely by the\n * server-side attempt status. The Angular peer of React's `<SignIn/>`. Draws the\n * instance's sign-in captcha when it is required (always-on, or a\n * `needs_captcha` challenge).\n *\n * ```html\n * <atlas-sign-in *atlasSignedOut afterUrl=\"/dashboard\"></atlas-sign-in>\n * ```\n */\n@Component({\n  selector: 'atlas-sign-in',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [AttemptFlowComponent, RecoveryCodesComponent],\n  template: `\n    @if (lastUsedLabel(); as label) {\n      <p class=\"atlas-text atlas-last-used-hint\" data-atlas=\"last-used\" [attr.data-atlas-method]=\"flow.lastMethod()\">\n        {{ t('signIn.lastUsed') }}: {{ label }}\n      </p>\n    }\n    @if (flow.recoveryCodes(); as codes) {\n      <atlas-recovery-codes [codes]=\"codes\" [busy]=\"flow.state().busy\" (saved)=\"flow.saveRecoveryCodes()\"></atlas-recovery-codes>\n    } @else {\n    <atlas-attempt-flow\n      [attempt]=\"flow.state().attempt\"\n      [busy]=\"flow.state().busy\"\n      [errors]=\"flow.state().errors\"\n      [sessionKept]=\"flow.state().sessionKept\"\n      titleKey=\"signIn.title\"\n      [captcha]=\"flow.captchaDrawn() ? flow.captcha : null\"\n      [firstFactors]=\"flow.firstFactors()\"\n      [preparedFactor]=\"flow.preparedFactor()\"\n      [offerEmailSecondFactor]=\"flow.settings()?.account?.emailSecondFactor === true\"\n      [emailedSecondFactor]=\"flow.emailSecondFactor()\"\n      (submitFlow)=\"flow.submit($event)\"\n      (chooseFactor)=\"flow.prepare($event)\"\n      [offerSmsSecondFactor]=\"flow.settings() !== null && flow.mfaChoices().sms\"\n      [textedSecondFactor]=\"flow.smsSecondFactor()\"\n      [enrollment]=\"flow.enrollment\"\n      [enrollmentState]=\"flow.enrollmentState()\"\n      (emailSecondFactor)=\"flow.sendEmailSecondFactor()\"\n      (smsSecondFactor)=\"flow.sendSmsSecondFactor()\"\n      (policyDeclined)=\"flow.declinePolicy($event)\"\n    ></atlas-attempt-flow>\n    }\n    @if (flow.state().attempt?.status !== 'complete' && signUpHref(); as href) {\n      <p class=\"atlas-footer\" data-atlas-sign-up-prompt=\"\">\n        {{ t('signIn.noAccount') }} <a class=\"atlas-link\" [href]=\"href\">{{ t('signIn.signUpLink') }}</a>\n      </p>\n    }\n  `,\n})\nexport class SignInComponent implements OnInit, OnDestroy {\n  private readonly atlas = inject(AtlasService);\n\n  /** Where to send the user once the flow completes. Reserved for host routing. */\n  @Input() afterUrl?: string;\n  /**\n   * Where \"No account? Sign up\" goes. Default: the instance's hosted sign-up\n   * page (carrying the visitor's referral). `null` hides it. Always shown, never\n   * only after a failed sign-in, so it says nothing about whether an email has an account.\n   */\n  @Input() signUpUrl?: string | null;\n\n  protected t(key: string): string {\n    return translate(this.atlas.localization, key);\n  }\n\n  /** \"Last used: Password\" on the identifier step, when the instance shows the hint. */\n  protected lastUsedLabel(): string | null {\n    if (this.flow.state().attempt) return null;\n    return lastUsedMethodLabel(this.flow.lastMethod(), (key) => this.t(key));\n  }\n\n  protected signUpHref(): string | null {\n    if (this.signUpUrl === null) return null;\n    if (this.signUpUrl) return this.signUpUrl;\n    try {\n      return hostedSignUp({\n        frontendApi: this.atlas.frontendApi,\n        redirectUrl: this.afterUrl ?? (typeof window !== 'undefined' ? window.location.href : undefined),\n        navigate: false,\n      });\n    } catch {\n      return null;\n    }\n  }\n\n  protected readonly flow = new AtlasFlowController(\n    this.atlas.createFapiClient(),\n    () => this.atlas.reload(),\n    // Resume mid-flow if an OAuth redirect came back owing a second factor.\n    this.atlas.pendingAttempt,\n    (key) => translate(this.atlas.localization, key),\n  );\n\n  ngOnInit(): void {\n    // If seeded from a pending attempt that is already pollable, start polling.\n    this.flow.syncPolling();\n    // §5 the instance's captcha settings (switching captcha on in the dashboard\n    // draws it here with no code change) and email delivery (no emailed-code\n    // option while the app cannot send email).\n    if (typeof window !== 'undefined') void this.flow.loadSettings();\n  }\n\n  ngOnDestroy(): void {\n    this.flow.destroy();\n  }\n}\n"]}