@atlasauth/angular 0.9.0 → 0.11.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/sign-in.component.mjs

@@ -95,6 +95,7 @@ export class SignInComponent {
       [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) {
@@ -102,7 +103,7 @@ export class SignInComponent {
         {{ 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", "offerEmailSecondFactor", "emailedSecondFactor", "offerSmsSecondFactor", "textedSecondFactor", "enrollment", "enrollmentState", "emailVerification"], outputs: ["submitFlow", "chooseFactor", "emailSecondFactor", "smsSecondFactor", "resend"] }, { kind: "component", type: RecoveryCodesComponent, selector: "atlas-recovery-codes", inputs: ["codes", "busy"], outputs: ["saved"] }], 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,
@@ -139,6 +140,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
       [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) {
@@ -153,4 +155,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             }], signUpUrl: [{
                 type: Input
             }] } });
-//# 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    ></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"]}
+//# 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"]}