@atlasauth/angular 0.2.1 → 0.4.0

package/dist/esm2022/lib/components/attempt-flow.component.mjs

@@ -1,6 +1,7 @@
 import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, inject, } from '@angular/core';
 import { nextStep } from '@atlasauth/js';
 import { AtlasService } from '../atlas.service';
+import { AtlasCaptchaSlotDirective } from '../directives/captcha-slot.directive';
 import { classFor } from '../appearance';
 import { translate } from '../i18n';
 import * as i0 from "@angular/core";
@@ -20,8 +21,24 @@ export class AttemptFlowComponent {
     busy = false;
     errors = [];
     titleKey = 'signIn.title';
+    /**
+     * The sign-in captcha, drawn above the submit button on the identifier step
+     * (an always-on sign-in captcha) and on the challenge step the server demands
+     * with `needs_captcha`. Null when the flow draws none.
+     */
+    captcha = null;
+    /**
+     * The first factors to offer on the `needs_first_factor` step — pass
+     * `AtlasFlowController.firstFactors()`, which drops email code / link while the
+     * app cannot deliver email. Null uses the server's list as-is.
+     */
+    firstFactors = null;
+    /** The first factor already sent (`AtlasFlowController.preparedFactor()`): its code is collected. */
+    preparedFactor = null;
     /** Emits the collected field values when the form is submitted. */
     submitFlow = new EventEmitter();
+    /** Emits when the user picks a first factor the server must send first (an emailed code). */
+    chooseFactor = new EventEmitter();
     values = {};
     t(key, vars) {
         return translate(this.atlas.localization, key, vars);
@@ -45,8 +62,26 @@ export class AttemptFlowComponent {
     step() {
         return this.attempt ? nextStep(this.attempt) : { kind: 'collect_identifier' };
     }
+    showCaptcha() {
+        const kind = this.step().kind;
+        return !!this.captcha && (kind === 'collect_identifier' || kind === 'collect_captcha');
+    }
+    /** The first factors on offer at a `needs_first_factor` step (empty on any other). */
+    offered() {
+        const step = this.step();
+        if (step.kind !== 'collect_first_factor')
+            return [];
+        return this.firstFactors ?? step.strategies;
+    }
+    showEmailCodeOption() {
+        return this.preparedFactor !== 'email_code' && this.offered().includes('email_code');
+    }
     showSubmit() {
         const kind = this.step().kind;
+        // Nothing to submit on a first-factor step that only offers an emailed code
+        // until that code is sent.
+        if (kind === 'collect_first_factor')
+            return this.fields().length > 0;
         return kind !== 'done' && kind !== 'await_oauth';
     }
     fields() {
@@ -54,8 +89,17 @@ export class AttemptFlowComponent {
         switch (step.kind) {
             case 'collect_identifier':
                 return [{ kind: 'input', name: 'identifier', labelKey: 'signIn.identifierLabel', type: 'email' }];
-            case 'collect_first_factor':
-                return [{ kind: 'input', name: 'password', labelKey: 'signIn.passwordLabel', type: 'password' }];
+            case 'collect_first_factor': {
+                if (this.preparedFactor === 'email_code') {
+                    return [{ kind: 'input', name: 'code', labelKey: 'signIn.emailCodeLabel', type: 'text' }];
+                }
+                // The password field unless the only offer is an emailed code (chosen
+                // with the button below the form).
+                const offered = this.offered();
+                return offered.includes('email_code') && !offered.includes('password')
+                    ? []
+                    : [{ kind: 'input', name: 'password', labelKey: 'signIn.passwordLabel', type: 'password' }];
+            }
             case 'collect_second_factor':
                 return [{ kind: 'input', name: 'code', labelKey: 'mfa.codeLabel', type: 'text' }];
             case 'enroll_second_factor':
@@ -69,6 +113,10 @@ export class AttemptFlowComponent {
                 return [{ kind: 'input', name: 'code', labelKey: 'signIn.emailCodeLabel', type: 'text' }];
             case 'collect_new_password':
                 return [{ kind: 'input', name: 'password', labelKey: 'reset.newPasswordLabel', type: 'password' }];
+            case 'collect_captcha':
+                // §5 the server withheld the attempt until a captcha clears. Solving the
+                // widget resubmits the identifier on its own; the button retries.
+                return [msg('captcha.prompt')];
             case 'await_oauth':
                 return [msg('signIn.magicLinkSent')];
             case 'done':
@@ -82,7 +130,7 @@ export class AttemptFlowComponent {
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AttemptFlowComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: AttemptFlowComponent, isStandalone: true, selector: "atlas-attempt-flow", inputs: { attempt: "attempt", busy: "busy", errors: "errors", titleKey: "titleKey" }, outputs: { submitFlow: "submitFlow" }, ngImport: i0, template: `
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: AttemptFlowComponent, isStandalone: true, selector: "atlas-attempt-flow", inputs: { attempt: "attempt", busy: "busy", errors: "errors", titleKey: "titleKey", captcha: "captcha", firstFactors: "firstFactors", preparedFactor: "preparedFactor" }, outputs: { submitFlow: "submitFlow", chooseFactor: "chooseFactor" }, ngImport: i0, template: `
     <div [class]="cls('card', 'atlas-card')">
       <h1 [class]="cls('headerTitle', 'atlas-title')">{{ t(titleKey) }}</h1>
 
@@ -98,6 +146,7 @@ export class AttemptFlowComponent {
               <input
                 [class]="cls('formFieldInput', 'atlas-input')"
                 [type]="f.type"
+                [attr.name]="f.name"
                 [value]="values[f.name] ?? ''"
                 (input)="setValue(f.name, $any($event.target).value)"
               />
@@ -110,14 +159,29 @@ export class AttemptFlowComponent {
           }
         }
 
+        @if (showCaptcha()) {
+          <div class="atlas-captcha" data-atlas-captcha="" [atlasCaptchaSlot]="captcha"></div>
+        }
+
         @if (showSubmit()) {
           <button [class]="cls('formButtonPrimary', 'atlas-button')" [disabled]="busy" type="submit">
             {{ t('signIn.submit') }}
           </button>
         }
+
+        @if (showEmailCodeOption()) {
+          <button
+            [class]="cls('formButtonSecondary', 'atlas-button-secondary')"
+            [disabled]="busy"
+            type="button"
+            (click)="chooseFactor.emit('email_code')"
+          >
+            {{ t('signIn.useEmailCode') }}
+          </button>
+        }
       </form>
     </div>
-  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, dependencies: [{ kind: "directive", type: AtlasCaptchaSlotDirective, selector: "[atlasCaptchaSlot]", inputs: ["atlasCaptchaSlot"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AttemptFlowComponent, decorators: [{
             type: Component,
@@ -125,6 +189,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     selector: 'atlas-attempt-flow',
                     standalone: true,
                     changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [AtlasCaptchaSlotDirective],
                     template: `
     <div [class]="cls('card', 'atlas-card')">
       <h1 [class]="cls('headerTitle', 'atlas-title')">{{ t(titleKey) }}</h1>
@@ -141,6 +206,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
               <input
                 [class]="cls('formFieldInput', 'atlas-input')"
                 [type]="f.type"
+                [attr.name]="f.name"
                 [value]="values[f.name] ?? ''"
                 (input)="setValue(f.name, $any($event.target).value)"
               />
@@ -153,11 +219,26 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
           }
         }
 
+        @if (showCaptcha()) {
+          <div class="atlas-captcha" data-atlas-captcha="" [atlasCaptchaSlot]="captcha"></div>
+        }
+
         @if (showSubmit()) {
           <button [class]="cls('formButtonPrimary', 'atlas-button')" [disabled]="busy" type="submit">
             {{ t('signIn.submit') }}
           </button>
         }
+
+        @if (showEmailCodeOption()) {
+          <button
+            [class]="cls('formButtonSecondary', 'atlas-button-secondary')"
+            [disabled]="busy"
+            type="button"
+            (click)="chooseFactor.emit('email_code')"
+          >
+            {{ t('signIn.useEmailCode') }}
+          </button>
+        }
       </form>
     </div>
   `,
@@ -170,11 +251,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: Input
             }], titleKey: [{
                 type: Input
+            }], captcha: [{
+                type: Input
+            }], firstFactors: [{
+                type: Input
+            }], preparedFactor: [{
+                type: Input
             }], submitFlow: [{
                 type: Output
+            }], chooseFactor: [{
+                type: Output
             }] } });
 /** A read-only message row: `labelKey` holds the i18n key of the text to show. */
 function msg(labelKey) {
     return { kind: 'message', name: '', labelKey, type: 'text' };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attempt-flow.component.js","sourceRoot":"","sources":["../../../../src/lib/components/attempt-flow.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n  inject,\n} from '@angular/core';\nimport { nextStep, type AttemptView, type FieldError } from '@atlasauth/js';\nimport { AtlasService } from '../atlas.service';\nimport { classFor, type ElementKey } from '../appearance';\nimport { translate } from '../i18n';\n\n/**\n * One rendered row of the flow. A uniform shape (rather than a discriminated\n * union) so the template accesses only fields that always exist — no reliance on\n * template control-flow narrowing of a loop variable, which varies by Angular\n * minor. For a `message` row, `labelKey` carries the message's i18n key.\n */\ninterface StepField {\n  kind: 'input' | 'message';\n  name: string;\n  labelKey: string;\n  type: string;\n}\n\n/**\n * The server-driven flow shell, shared by `<atlas-sign-in>` and\n * `<atlas-sign-up>`. The Angular peer of React's internal `AttemptFlow`.\n *\n * It contains NO decision about what comes next: it renders whatever `status`\n * the server returned, mapped through `nextStep` from `@atlasauth/js` (the same\n * exhaustive mapping the React SDK uses), so adding a step is a server change\n * and an out-of-date client degrades to a visible \"please update\" message rather\n * than a blank screen.\n */\n@Component({\n  selector: 'atlas-attempt-flow',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"cls('card', 'atlas-card')\">\n      <h1 [class]=\"cls('headerTitle', 'atlas-title')\">{{ t(titleKey) }}</h1>\n\n      @for (error of formErrors(); track error.code) {\n        <p [class]=\"cls('formFieldError', 'atlas-error')\" role=\"alert\">{{ error.message }}</p>\n      }\n\n      <form (submit)=\"onSubmit($event)\">\n        @for (f of fields(); track $index) {\n          @if (f.kind === 'input') {\n            <label class=\"atlas-field\">\n              <span>{{ t(f.labelKey) }}</span>\n              <input\n                [class]=\"cls('formFieldInput', 'atlas-input')\"\n                [type]=\"f.type\"\n                [value]=\"values[f.name] ?? ''\"\n                (input)=\"setValue(f.name, $any($event.target).value)\"\n              />\n              @for (error of fieldErrorsFor(f.name); track error.code) {\n                <span [class]=\"cls('formFieldError', 'atlas-error')\">{{ error.message }}</span>\n              }\n            </label>\n          } @else {\n            <p>{{ t(f.labelKey) }}</p>\n          }\n        }\n\n        @if (showSubmit()) {\n          <button [class]=\"cls('formButtonPrimary', 'atlas-button')\" [disabled]=\"busy\" type=\"submit\">\n            {{ t('signIn.submit') }}\n          </button>\n        }\n      </form>\n    </div>\n  `,\n})\nexport class AttemptFlowComponent {\n  private readonly atlas = inject(AtlasService);\n\n  @Input() attempt: AttemptView | null = null;\n  @Input() busy = false;\n  @Input() errors: FieldError[] = [];\n  @Input() titleKey = 'signIn.title';\n\n  /** Emits the collected field values when the form is submitted. */\n  @Output() submitFlow = new EventEmitter<Record<string, string>>();\n\n  protected values: Record<string, string> = {};\n\n  protected t(key: string, vars?: Record<string, string>): string {\n    return translate(this.atlas.localization, key, vars);\n  }\n\n  protected cls(key: ElementKey, base: string): string {\n    return classFor(key, this.atlas.appearance, base);\n  }\n\n  protected setValue(name: string, value: string): void {\n    this.values = { ...this.values, [name]: value };\n  }\n\n  protected onSubmit(event: Event): void {\n    event.preventDefault();\n    this.submitFlow.emit(this.values);\n  }\n\n  protected formErrors(): FieldError[] {\n    return this.errors.filter((error) => !error.param);\n  }\n\n  protected fieldErrorsFor(name: string): FieldError[] {\n    return this.errors.filter((error) => error.param === name);\n  }\n\n  private step() {\n    return this.attempt ? nextStep(this.attempt) : ({ kind: 'collect_identifier' } as const);\n  }\n\n  protected showSubmit(): boolean {\n    const kind = this.step().kind;\n    return kind !== 'done' && kind !== 'await_oauth';\n  }\n\n  protected fields(): StepField[] {\n    const step = this.step();\n    switch (step.kind) {\n      case 'collect_identifier':\n        return [{ kind: 'input', name: 'identifier', labelKey: 'signIn.identifierLabel', type: 'email' }];\n      case 'collect_first_factor':\n        return [{ kind: 'input', name: 'password', labelKey: 'signIn.passwordLabel', type: 'password' }];\n      case 'collect_second_factor':\n        return [{ kind: 'input', name: 'code', labelKey: 'mfa.codeLabel', type: 'text' }];\n      case 'enroll_second_factor':\n        // Two consecutive codes (§5.6): a phone with a fast clock fails here\n        // rather than on every sign-in afterwards.\n        return [\n          { kind: 'input', name: 'code', labelKey: 'mfa.enrollFirstCodeLabel', type: 'text' },\n          { kind: 'input', name: 'secondCode', labelKey: 'mfa.enrollSecondCodeLabel', type: 'text' },\n        ];\n      case 'collect_email_code':\n        return [{ kind: 'input', name: 'code', labelKey: 'signIn.emailCodeLabel', type: 'text' }];\n      case 'collect_new_password':\n        return [{ kind: 'input', name: 'password', labelKey: 'reset.newPasswordLabel', type: 'password' }];\n      case 'await_oauth':\n        return [msg('signIn.magicLinkSent')];\n      case 'done':\n        return [msg('signIn.checkOtherTab')];\n      case 'restart':\n        return [msg('error.generic')];\n      default:\n        // A status this SDK version does not know. An honest message beats a\n        // blank login box the user cannot act on.\n        return [msg('error.generic')];\n    }\n  }\n}\n\n/** A read-only message row: `labelKey` holds the i18n key of the text to show. */\nfunction msg(labelKey: string): StepField {\n  return { kind: 'message', name: '', labelKey, type: 'text' };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attempt-flow.component.js","sourceRoot":"","sources":["../../../../src/lib/components/attempt-flow.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n  inject,\n} from '@angular/core';\nimport { nextStep, type AttemptView, type CaptchaController, type FieldError } from '@atlasauth/js';\nimport { AtlasService } from '../atlas.service';\nimport { AtlasCaptchaSlotDirective } from '../directives/captcha-slot.directive';\nimport { classFor, type ElementKey } from '../appearance';\nimport { translate } from '../i18n';\n\n/**\n * One rendered row of the flow. A uniform shape (rather than a discriminated\n * union) so the template accesses only fields that always exist — no reliance on\n * template control-flow narrowing of a loop variable, which varies by Angular\n * minor. For a `message` row, `labelKey` carries the message's i18n key.\n */\ninterface StepField {\n  kind: 'input' | 'message';\n  name: string;\n  labelKey: string;\n  type: string;\n}\n\n/**\n * The server-driven flow shell, shared by `<atlas-sign-in>` and\n * `<atlas-sign-up>`. The Angular peer of React's internal `AttemptFlow`.\n *\n * It contains NO decision about what comes next: it renders whatever `status`\n * the server returned, mapped through `nextStep` from `@atlasauth/js` (the same\n * exhaustive mapping the React SDK uses), so adding a step is a server change\n * and an out-of-date client degrades to a visible \"please update\" message rather\n * than a blank screen.\n */\n@Component({\n  selector: 'atlas-attempt-flow',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [AtlasCaptchaSlotDirective],\n  template: `\n    <div [class]=\"cls('card', 'atlas-card')\">\n      <h1 [class]=\"cls('headerTitle', 'atlas-title')\">{{ t(titleKey) }}</h1>\n\n      @for (error of formErrors(); track error.code) {\n        <p [class]=\"cls('formFieldError', 'atlas-error')\" role=\"alert\">{{ error.message }}</p>\n      }\n\n      <form (submit)=\"onSubmit($event)\">\n        @for (f of fields(); track $index) {\n          @if (f.kind === 'input') {\n            <label class=\"atlas-field\">\n              <span>{{ t(f.labelKey) }}</span>\n              <input\n                [class]=\"cls('formFieldInput', 'atlas-input')\"\n                [type]=\"f.type\"\n                [attr.name]=\"f.name\"\n                [value]=\"values[f.name] ?? ''\"\n                (input)=\"setValue(f.name, $any($event.target).value)\"\n              />\n              @for (error of fieldErrorsFor(f.name); track error.code) {\n                <span [class]=\"cls('formFieldError', 'atlas-error')\">{{ error.message }}</span>\n              }\n            </label>\n          } @else {\n            <p>{{ t(f.labelKey) }}</p>\n          }\n        }\n\n        @if (showCaptcha()) {\n          <div class=\"atlas-captcha\" data-atlas-captcha=\"\" [atlasCaptchaSlot]=\"captcha\"></div>\n        }\n\n        @if (showSubmit()) {\n          <button [class]=\"cls('formButtonPrimary', 'atlas-button')\" [disabled]=\"busy\" type=\"submit\">\n            {{ t('signIn.submit') }}\n          </button>\n        }\n\n        @if (showEmailCodeOption()) {\n          <button\n            [class]=\"cls('formButtonSecondary', 'atlas-button-secondary')\"\n            [disabled]=\"busy\"\n            type=\"button\"\n            (click)=\"chooseFactor.emit('email_code')\"\n          >\n            {{ t('signIn.useEmailCode') }}\n          </button>\n        }\n      </form>\n    </div>\n  `,\n})\nexport class AttemptFlowComponent {\n  private readonly atlas = inject(AtlasService);\n\n  @Input() attempt: AttemptView | null = null;\n  @Input() busy = false;\n  @Input() errors: FieldError[] = [];\n  @Input() titleKey = 'signIn.title';\n  /**\n   * The sign-in captcha, drawn above the submit button on the identifier step\n   * (an always-on sign-in captcha) and on the challenge step the server demands\n   * with `needs_captcha`. Null when the flow draws none.\n   */\n  @Input() captcha: CaptchaController | null = null;\n  /**\n   * The first factors to offer on the `needs_first_factor` step — pass\n   * `AtlasFlowController.firstFactors()`, which drops email code / link while the\n   * app cannot deliver email. Null uses the server's list as-is.\n   */\n  @Input() firstFactors: string[] | null = null;\n  /** The first factor already sent (`AtlasFlowController.preparedFactor()`): its code is collected. */\n  @Input() preparedFactor: string | null = null;\n\n  /** Emits the collected field values when the form is submitted. */\n  @Output() submitFlow = new EventEmitter<Record<string, string>>();\n  /** Emits when the user picks a first factor the server must send first (an emailed code). */\n  @Output() chooseFactor = new EventEmitter<'email_code'>();\n\n  protected values: Record<string, string> = {};\n\n  protected t(key: string, vars?: Record<string, string>): string {\n    return translate(this.atlas.localization, key, vars);\n  }\n\n  protected cls(key: ElementKey, base: string): string {\n    return classFor(key, this.atlas.appearance, base);\n  }\n\n  protected setValue(name: string, value: string): void {\n    this.values = { ...this.values, [name]: value };\n  }\n\n  protected onSubmit(event: Event): void {\n    event.preventDefault();\n    this.submitFlow.emit(this.values);\n  }\n\n  protected formErrors(): FieldError[] {\n    return this.errors.filter((error) => !error.param);\n  }\n\n  protected fieldErrorsFor(name: string): FieldError[] {\n    return this.errors.filter((error) => error.param === name);\n  }\n\n  private step() {\n    return this.attempt ? nextStep(this.attempt) : ({ kind: 'collect_identifier' } as const);\n  }\n\n  protected showCaptcha(): boolean {\n    const kind = this.step().kind;\n    return !!this.captcha && (kind === 'collect_identifier' || kind === 'collect_captcha');\n  }\n\n  /** The first factors on offer at a `needs_first_factor` step (empty on any other). */\n  private offered(): string[] {\n    const step = this.step();\n    if (step.kind !== 'collect_first_factor') return [];\n    return this.firstFactors ?? step.strategies;\n  }\n\n  protected showEmailCodeOption(): boolean {\n    return this.preparedFactor !== 'email_code' && this.offered().includes('email_code');\n  }\n\n  protected showSubmit(): boolean {\n    const kind = this.step().kind;\n    // Nothing to submit on a first-factor step that only offers an emailed code\n    // until that code is sent.\n    if (kind === 'collect_first_factor') return this.fields().length > 0;\n    return kind !== 'done' && kind !== 'await_oauth';\n  }\n\n  protected fields(): StepField[] {\n    const step = this.step();\n    switch (step.kind) {\n      case 'collect_identifier':\n        return [{ kind: 'input', name: 'identifier', labelKey: 'signIn.identifierLabel', type: 'email' }];\n      case 'collect_first_factor': {\n        if (this.preparedFactor === 'email_code') {\n          return [{ kind: 'input', name: 'code', labelKey: 'signIn.emailCodeLabel', type: 'text' }];\n        }\n        // The password field unless the only offer is an emailed code (chosen\n        // with the button below the form).\n        const offered = this.offered();\n        return offered.includes('email_code') && !offered.includes('password')\n          ? []\n          : [{ kind: 'input', name: 'password', labelKey: 'signIn.passwordLabel', type: 'password' }];\n      }\n      case 'collect_second_factor':\n        return [{ kind: 'input', name: 'code', labelKey: 'mfa.codeLabel', type: 'text' }];\n      case 'enroll_second_factor':\n        // Two consecutive codes (§5.6): a phone with a fast clock fails here\n        // rather than on every sign-in afterwards.\n        return [\n          { kind: 'input', name: 'code', labelKey: 'mfa.enrollFirstCodeLabel', type: 'text' },\n          { kind: 'input', name: 'secondCode', labelKey: 'mfa.enrollSecondCodeLabel', type: 'text' },\n        ];\n      case 'collect_email_code':\n        return [{ kind: 'input', name: 'code', labelKey: 'signIn.emailCodeLabel', type: 'text' }];\n      case 'collect_new_password':\n        return [{ kind: 'input', name: 'password', labelKey: 'reset.newPasswordLabel', type: 'password' }];\n      case 'collect_captcha':\n        // §5 the server withheld the attempt until a captcha clears. Solving the\n        // widget resubmits the identifier on its own; the button retries.\n        return [msg('captcha.prompt')];\n      case 'await_oauth':\n        return [msg('signIn.magicLinkSent')];\n      case 'done':\n        return [msg('signIn.checkOtherTab')];\n      case 'restart':\n        return [msg('error.generic')];\n      default:\n        // A status this SDK version does not know. An honest message beats a\n        // blank login box the user cannot act on.\n        return [msg('error.generic')];\n    }\n  }\n}\n\n/** A read-only message row: `labelKey` holds the i18n key of the text to show. */\nfunction msg(labelKey: string): StepField {\n  return { kind: 'message', name: '', labelKey, type: 'text' };\n}\n"]}

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, nextStep, offeredFirstFactors, pollAttempt, prepareFactor, 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,115 @@ 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);
+    /**
+     * The first factor the server was asked to send ({@link prepare}) on the
+     * current `needs_first_factor` step — the form then collects its code. Null
+     * otherwise.
+     */
+    preparedFactor = signal(null);
     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();
+        }
+    }
+    /**
+     * The first factors to offer on a `needs_first_factor` step: the server's list
+     * without email code / link while the app cannot deliver email
+     * (`settings.emailDelivery.available === false`). Empty on any other step.
+     */
+    firstFactors() {
+        const attempt = this.state().attempt;
+        const step = attempt ? nextStep(attempt) : null;
+        return step?.kind === 'collect_first_factor'
+            ? offeredFirstFactors(step.strategies, this.settings()?.emailDelivery)
+            : [];
+    }
+    /**
+     * True when email + password sign-up cannot complete because the app cannot
+     * send the verification email (`settings.emailDelivery.passwordSignUp === false`):
+     * `<atlas-sign-up>` shows the "can't send email" notice instead of the form.
+     */
+    signUpEmailUnavailable() {
+        return this.settings()?.emailDelivery.passwordSignUp === false;
+    }
+    /** False when a password reset email cannot be delivered — hide "Forgot password?". */
+    passwordResetAvailable() {
+        return this.settings()?.emailDelivery.passwordReset !== false;
+    }
+    /**
+     * Ask the server to email a sign-in code for the current `needs_first_factor`
+     * step (`POST …/prepare_first_factor`); the form then collects the code, which
+     * {@link submit} posts as the `email_code` strategy.
+     */
+    async prepare(strategy) {
+        if (!this.firstFactors().includes(strategy))
+            return;
+        this.state.update((current) => ({ ...current, busy: true, errors: [] }));
+        const next = await prepareFactor(this.client, this.state(), strategy);
+        this.setState(next);
+        if (!next.errors.length)
+            this.preparedFactor.set(strategy);
+    }
+    /** 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);
+        // A prepared factor belongs to the first-factor step it was sent for.
+        if (next.attempt?.status !== 'needs_first_factor')
+            this.preparedFactor.set(null);
+        this.syncCaptcha();
     }
     /**
      * Advance the flow with the values the user typed. On completion, exchange the
@@ -29,8 +127,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 +181,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 +201,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  nextStep,\n  offeredFirstFactors,\n  pollAttempt,\n  prepareFactor,\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  /**\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<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  /**\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  }\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,15 @@ 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) and email delivery (no emailed-code
+        // option while the app cannot send email).
+        if (typeof window !== 'undefined')
+            void this.flow.loadSettings();
     }
     ngOnDestroy() {
         this.flow.destroy();
@@ -32,9 +40,13 @@ export class SignInComponent {
       [busy]="flow.state().busy"
       [errors]="flow.state().errors"
       titleKey="signIn.title"
+      [captcha]="flow.captchaDrawn() ? flow.captcha : null"
+      [firstFactors]="flow.firstFactors()"
+      [preparedFactor]="flow.preparedFactor()"
       (submitFlow)="flow.submit($event)"
+      (chooseFactor)="flow.prepare($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", "firstFactors", "preparedFactor"], outputs: ["submitFlow", "chooseFactor"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignInComponent, decorators: [{
             type: Component,
@@ -49,11 +61,15 @@ 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"
+      [firstFactors]="flow.firstFactors()"
+      [preparedFactor]="flow.preparedFactor()"
       (submitFlow)="flow.submit($event)"
+      (chooseFactor)="flow.prepare($event)"
     ></atlas-attempt-flow>
   `,
                 }]
         }], propDecorators: { afterUrl: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbi1pbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvc2lnbi1pbi5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLHVCQUF1QixFQUN2QixTQUFTLEVBQ1QsS0FBSyxFQUdMLE1BQU0sR0FDUCxNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDaEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNwQyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7QUFFeEQ7Ozs7Ozs7OztHQVNHO0FBb0JILE1BQU0sT0FBTyxlQUFlO0lBQ1QsS0FBSyxHQUFHLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUU5QyxpRkFBaUY7SUFDeEUsUUFBUSxDQUFVO0lBRVIsSUFBSSxHQUFHLElBQUksbUJBQW1CLENBQy9DLElBQUksQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLEVBQUUsRUFDN0IsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUU7SUFDekIsd0VBQXdFO0lBQ3hFLElBQUksQ0FBQyxLQUFLLENBQUMsY0FBYyxFQUN6QixDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsWUFBWSxFQUFFLEdBQUcsQ0FBQyxDQUNqRCxDQUFDO0lBRUYsUUFBUTtRQUNOLDRFQUE0RTtRQUM1RSxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ3hCLDRFQUE0RTtRQUM1RSx5RUFBeUU7UUFDekUsMkNBQTJDO1FBQzNDLElBQUksT0FBTyxNQUFNLEtBQUssV0FBVztZQUFFLEtBQUssSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUNuRSxDQUFDO0lBRUQsV0FBVztRQUNULElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDdEIsQ0FBQzt3R0F6QlUsZUFBZTs0RkFBZixlQUFlLDJHQWRoQjs7Ozs7Ozs7Ozs7O0dBWVQsNERBYlMsb0JBQW9COzs0RkFlbkIsZUFBZTtrQkFuQjNCLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGVBQWU7b0JBQ3pCLFVBQVUsRUFBRSxJQUFJO29CQUNoQixlQUFlLEVBQUUsdUJBQXVCLENBQUMsTUFBTTtvQkFDL0MsT0FBTyxFQUFFLENBQUMsb0JBQW9CLENBQUM7b0JBQy9CLFFBQVEsRUFBRTs7Ozs7Ozs7Ozs7O0dBWVQ7aUJBQ0Y7OEJBS1UsUUFBUTtzQkFBaEIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuICBDb21wb25lbnQsXG4gIElucHV0LFxuICBPbkRlc3Ryb3ksXG4gIE9uSW5pdCxcbiAgaW5qZWN0LFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEF0bGFzU2VydmljZSB9IGZyb20gJy4uL2F0bGFzLnNlcnZpY2UnO1xuaW1wb3J0IHsgdHJhbnNsYXRlIH0gZnJvbSAnLi4vaTE4bic7XG5pbXBvcnQgeyBBdHRlbXB0Rmxvd0NvbXBvbmVudCB9IGZyb20gJy4vYXR0ZW1wdC1mbG93LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBBdGxhc0Zsb3dDb250cm9sbGVyIH0gZnJvbSAnLi9mbG93LWNvbnRyb2xsZXInO1xuXG4vKipcbiAqIGA8YXRsYXMtc2lnbi1pbj5gIOKAlCB0aGUgZnVsbCwgbXVsdGktc3RlcCBzaWduLWluIGZsb3cgZHJpdmVuIGVudGlyZWx5IGJ5IHRoZVxuICogc2VydmVyLXNpZGUgYXR0ZW1wdCBzdGF0dXMuIFRoZSBBbmd1bGFyIHBlZXIgb2YgUmVhY3QncyBgPFNpZ25Jbi8+YC4gRHJhd3MgdGhlXG4gKiBpbnN0YW5jZSdzIHNpZ24taW4gY2FwdGNoYSB3aGVuIGl0IGlzIHJlcXVpcmVkIChhbHdheXMtb24sIG9yIGFcbiAqIGBuZWVkc19jYXB0Y2hhYCBjaGFsbGVuZ2UpLlxuICpcbiAqIGBgYGh0bWxcbiAqIDxhdGxhcy1zaWduLWluICphdGxhc1NpZ25lZE91dCBhZnRlclVybD1cIi9kYXNoYm9hcmRcIj48L2F0bGFzLXNpZ24taW4+XG4gKiBgYGBcbiAqL1xuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYXRsYXMtc2lnbi1pbicsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBpbXBvcnRzOiBbQXR0ZW1wdEZsb3dDb21wb25lbnRdLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxhdGxhcy1hdHRlbXB0LWZsb3dcbiAgICAgIFthdHRlbXB0XT1cImZsb3cuc3RhdGUoKS5hdHRlbXB0XCJcbiAgICAgIFtidXN5XT1cImZsb3cuc3RhdGUoKS5idXN5XCJcbiAgICAgIFtlcnJvcnNdPVwiZmxvdy5zdGF0ZSgpLmVycm9yc1wiXG4gICAgICB0aXRsZUtleT1cInNpZ25Jbi50aXRsZVwiXG4gICAgICBbY2FwdGNoYV09XCJmbG93LmNhcHRjaGFEcmF3bigpID8gZmxvdy5jYXB0Y2hhIDogbnVsbFwiXG4gICAgICBbZmlyc3RGYWN0b3JzXT1cImZsb3cuZmlyc3RGYWN0b3JzKClcIlxuICAgICAgW3ByZXBhcmVkRmFjdG9yXT1cImZsb3cucHJlcGFyZWRGYWN0b3IoKVwiXG4gICAgICAoc3VibWl0Rmxvdyk9XCJmbG93LnN1Ym1pdCgkZXZlbnQpXCJcbiAgICAgIChjaG9vc2VGYWN0b3IpPVwiZmxvdy5wcmVwYXJlKCRldmVudClcIlxuICAgID48L2F0bGFzLWF0dGVtcHQtZmxvdz5cbiAgYCxcbn0pXG5leHBvcnQgY2xhc3MgU2lnbkluQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0LCBPbkRlc3Ryb3kge1xuICBwcml2YXRlIHJlYWRvbmx5IGF0bGFzID0gaW5qZWN0KEF0bGFzU2VydmljZSk7XG5cbiAgLyoqIFdoZXJlIHRvIHNlbmQgdGhlIHVzZXIgb25jZSB0aGUgZmxvdyBjb21wbGV0ZXMuIFJlc2VydmVkIGZvciBob3N0IHJvdXRpbmcuICovXG4gIEBJbnB1dCgpIGFmdGVyVXJsPzogc3RyaW5nO1xuXG4gIHByb3RlY3RlZCByZWFkb25seSBmbG93ID0gbmV3IEF0bGFzRmxvd0NvbnRyb2xsZXIoXG4gICAgdGhpcy5hdGxhcy5jcmVhdGVGYXBpQ2xpZW50KCksXG4gICAgKCkgPT4gdGhpcy5hdGxhcy5yZWxvYWQoKSxcbiAgICAvLyBSZXN1bWUgbWlkLWZsb3cgaWYgYW4gT0F1dGggcmVkaXJlY3QgY2FtZSBiYWNrIG93aW5nIGEgc2Vjb25kIGZhY3Rvci5cbiAgICB0aGlzLmF0bGFzLnBlbmRpbmdBdHRlbXB0LFxuICAgIChrZXkpID0+IHRyYW5zbGF0ZSh0aGlzLmF0bGFzLmxvY2FsaXphdGlvbiwga2V5KSxcbiAgKTtcblxuICBuZ09uSW5pdCgpOiB2b2lkIHtcbiAgICAvLyBJZiBzZWVkZWQgZnJvbSBhIHBlbmRpbmcgYXR0ZW1wdCB0aGF0IGlzIGFscmVhZHkgcG9sbGFibGUsIHN0YXJ0IHBvbGxpbmcuXG4gICAgdGhpcy5mbG93LnN5bmNQb2xsaW5nKCk7XG4gICAgLy8gwqc1IHRoZSBpbnN0YW5jZSdzIGNhcHRjaGEgc2V0dGluZ3MgKHN3aXRjaGluZyBjYXB0Y2hhIG9uIGluIHRoZSBkYXNoYm9hcmRcbiAgICAvLyBkcmF3cyBpdCBoZXJlIHdpdGggbm8gY29kZSBjaGFuZ2UpIGFuZCBlbWFpbCBkZWxpdmVyeSAobm8gZW1haWxlZC1jb2RlXG4gICAgLy8gb3B0aW9uIHdoaWxlIHRoZSBhcHAgY2Fubm90IHNlbmQgZW1haWwpLlxuICAgIGlmICh0eXBlb2Ygd2luZG93ICE9PSAndW5kZWZpbmVkJykgdm9pZCB0aGlzLmZsb3cubG9hZFNldHRpbmdzKCk7XG4gIH1cblxuICBuZ09uRGVzdHJveSgpOiB2b2lkIHtcbiAgICB0aGlzLmZsb3cuZGVzdHJveSgpO1xuICB9XG59XG4iXX0=