@atlasauth/angular 0.1.0

package/dist/esm2022/lib/atlas.service.mjs

@@ -0,0 +1,329 @@
+import { Injectable, PLATFORM_ID, computed, inject, } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { FapiClient, TokenCache, getProviderToken as fetchProviderToken, msUntilRefresh, readExpiry, readRedirectResult, stripRedirectParams, } from '@atlasauth/js';
+import { evaluate } from '@atlasauth/authz';
+import { ATLAS_OPTIONS } from './atlas.config';
+import { cssVariables, resolveTokens } from './appearance';
+import { EN_US, withFallback } from './i18n';
+import * as i0 from "@angular/core";
+/**
+ * `AtlasService` — the Angular peer of React's `<AtlasProvider>` + hooks.
+ *
+ * It holds exactly one thing that matters in memory: the short-lived JWT, in a
+ * {@link TokenCache}. Not localStorage, not a cookie this code writes — the
+ * refresh token is HttpOnly so browser script never touches it, and the JWT
+ * lives only as long as the tab. Anything persisted would survive the tab and
+ * become the first thing an XSS reads.
+ *
+ * Reactive auth state is exposed two ways so callers can pick their idiom:
+ *  - RxJS observables (`user$`, `session$`, `isSignedIn$`, …) — the primary API,
+ *    the analogue of the React hooks' return values.
+ *  - Angular signals (`user`, `session`, `isSignedIn`, …) — the same values as
+ *    `Signal<T>`, for templates and `computed()`.
+ *
+ * The imperative methods (`signOut`, `getToken`, `getProviderToken`,
+ * `setActiveOrganization`, `reload`) mirror the actions the hooks return.
+ */
+export class AtlasService {
+    options = inject(ATLAS_OPTIONS);
+    platformId = inject(PLATFORM_ID);
+    isBrowser = isPlatformBrowser(this.platformId);
+    baseUrl;
+    publishableKey;
+    doFetch;
+    cache = new TokenCache();
+    fapiClient;
+    refreshTimer = null;
+    catalog;
+    /**
+     * A sign-in attempt handed back by an OAuth redirect that still needs a second
+     * factor (no session was issued). Null in the ordinary case; the `<atlas-sign-in>`
+     * flow seeds itself from this so the user resumes at the 2FA step. Captured
+     * once, synchronously, at construction — before any flow component reads it.
+     */
+    pendingAttempt;
+    // --- Reactive state (source of truth) ---------------------------------------
+    _status = new BehaviorSubject('loading');
+    _user = new BehaviorSubject(null);
+    _session = new BehaviorSubject(null);
+    _claims = new BehaviorSubject(null);
+    _memberships = new BehaviorSubject([]);
+    /** The three-state auth lifecycle: `loading` → `signed_in` | `signed_out`. */
+    status$ = this._status.asObservable();
+    user$ = this._user.asObservable();
+    session$ = this._session.asObservable();
+    claims$ = this._claims.asObservable();
+    memberships$ = this._memberships.asObservable();
+    /**
+     * True once the SDK has finished its first boot. Distinguishing "still loading"
+     * from "signed out" is what lets a template avoid the flash of a sign-in form
+     * on every page load.
+     */
+    isLoaded$ = this.status$.pipe(map((s) => s !== 'loading'), distinctUntilChanged());
+    isSignedIn$ = this.status$.pipe(map((s) => s === 'signed_in'), distinctUntilChanged());
+    /** The active organization membership, derived from the token's `org_id` claim. */
+    organization$ = combineLatest([
+        this._memberships,
+        this._claims,
+    ]).pipe(map(([memberships, claims]) => memberships.find((m) => m.organization.id === claims?.org_id) ?? null));
+    // --- Signal mirror ----------------------------------------------------------
+    status = toSignal(this.status$, { initialValue: 'loading' });
+    user = toSignal(this.user$, { initialValue: null });
+    session = toSignal(this.session$, { initialValue: null });
+    claims = toSignal(this.claims$, { initialValue: null });
+    memberships = toSignal(this.memberships$, {
+        initialValue: [],
+    });
+    isLoaded = computed(() => this.status() !== 'loading');
+    isSignedIn = computed(() => this.status() === 'signed_in');
+    organization = computed(() => {
+        const orgId = this.claims()?.org_id;
+        return this.memberships().find((m) => m.organization.id === orgId) ?? null;
+    });
+    constructor() {
+        const options = this.options;
+        this.publishableKey = options.publishableKey;
+        this.baseUrl = options.frontendApi ?? '';
+        this.doFetch = options.fetchImpl ?? ((...args) => fetch(...args));
+        this.catalog = options.localization ? withFallback(options.localization) : EN_US;
+        this.fapiClient = new FapiClient({
+            publishableKey: this.publishableKey,
+            baseUrl: this.baseUrl,
+            fetchImpl: this.doFetch,
+        });
+        // Captured synchronously (not in an async init) so it is available before any
+        // flow component reads it: a needs_second_factor redirect carries a status but
+        // no ticket, and that is what the 2FA resume seeds from.
+        this.pendingAttempt = this.isBrowser ? this.readPendingAttempt() : null;
+        // Boot once, browser only. On the server there is no cookie jar to read a
+        // session from, so we leave the state at `loading` and let hydration boot it.
+        if (this.isBrowser) {
+            void this.boot();
+        }
+    }
+    ngOnDestroy() {
+        this.clearRefreshTimer();
+        this._status.complete();
+        this._user.complete();
+        this._session.complete();
+        this._claims.complete();
+        this._memberships.complete();
+    }
+    // --- Configuration accessors ------------------------------------------------
+    get appearance() {
+        return this.options.appearance;
+    }
+    get localization() {
+        return this.catalog;
+    }
+    get frontendApi() {
+        return this.baseUrl;
+    }
+    /** Tokens as CSS custom properties, for a host element to inherit. */
+    appearanceVariables() {
+        return cssVariables(resolveTokens(this.options.appearance));
+    }
+    /** A fresh {@link FapiClient} for driving a sign-in/sign-up flow. */
+    createFapiClient() {
+        return new FapiClient({ publishableKey: this.publishableKey, baseUrl: this.baseUrl });
+    }
+    // --- Imperative API (mirrors the React hooks' actions) ----------------------
+    /**
+     * The current session's JWT, always fresh: if the cached token is within 5s of
+     * expiry it is refreshed first rather than handed over. Null when signed out.
+     */
+    async getToken() {
+        const usable = this.cache.get(5_000);
+        if (usable)
+            return usable.jwt;
+        await this.refresh();
+        return this.cache.get(5_000)?.jwt ?? null;
+    }
+    /**
+     * The signed-in user's OWN live access token at a connected provider (Google,
+     * GitHub, …), so the app can call that provider's API from the browser. Null
+     * when there is no usable token — no linked account, or the provider granted /
+     * kept none. The server refreshes a stale token on read; the refresh token is
+     * never exposed.
+     */
+    getProviderToken(provider) {
+        return fetchProviderToken(this.fapiClient, provider);
+    }
+    /** Imperative `has()` — the same evaluation `*atlasProtect` renders on. */
+    has(condition) {
+        return evaluate(this._claims.value, condition).allowed;
+    }
+    /** Revoke the current session server-side and drop all local auth state. */
+    async signOut() {
+        const current = this.cache.peek();
+        if (current) {
+            await this.call(`/v1/client/sessions/${current.sessionId}/revoke`, {
+                method: 'POST',
+            }).catch(() => undefined);
+        }
+        this.clearRefreshTimer();
+        this.cache.clear();
+        this._status.next('signed_out');
+        this._user.next(null);
+        this._session.next(null);
+        this._claims.next(null);
+        this._memberships.next([]);
+    }
+    /**
+     * Switch the active organization (or `null` for the personal account). The
+     * new token carries the new org claims, so the app's permission checks update
+     * without a re-login.
+     */
+    async setActiveOrganization(organizationId) {
+        const current = this.cache.peek();
+        if (!current)
+            return;
+        const response = await this.call(`/v1/client/sessions/${current.sessionId}/touch`, {
+            method: 'POST',
+            body: JSON.stringify({ active_organization_id: organizationId }),
+        });
+        if (!response.ok)
+            return;
+        const body = (await response.json());
+        this.applyToken(body.jwt, current.sessionId);
+        await this.reload();
+    }
+    /** Re-read `/v1/client`: refresh user, session, memberships and status. */
+    async reload() {
+        try {
+            const response = await this.call('/v1/client');
+            if (!response.ok)
+                throw new Error('boot failed');
+            const body = (await response.json());
+            if (!body.session || !body.user) {
+                this.clearRefreshTimer();
+                this.cache.clear();
+                this._status.next('signed_out');
+                this._user.next(null);
+                this._session.next(null);
+                this._claims.next(null);
+                this._memberships.next([]);
+                return;
+            }
+            this._user.next(body.user);
+            this._session.next(body.session);
+            this._memberships.next(body.organization_memberships ?? []);
+            if (body.jwt)
+                this.applyToken(body.jwt, body.session.id);
+            this._status.next('signed_in');
+            this.scheduleRefresh();
+        }
+        catch {
+            // A failed boot is NOT signed-out. Rendering a sign-in form because the
+            // network hiccuped throws away a perfectly good session and forces a
+            // needless re-authentication. Only promote loading → signed_out.
+            if (this._status.value === 'loading')
+                this._status.next('signed_out');
+        }
+    }
+    // --- Internals --------------------------------------------------------------
+    /**
+     * §6.3 step 3: complete a redirect-based sign-in, then boot. An OAuth or
+     * hosted-page flow lands back with a one-time ticket in the URL; exchange it
+     * for cookies, scrub the URL so a reload cannot replay it, THEN read the
+     * session. A redirect carrying only a status (a second factor is still owed)
+     * has no ticket, so nothing is exchanged and the app boots signed-out.
+     */
+    async boot() {
+        const result = readRedirectResult(window.location.search);
+        if (result?.ticket) {
+            await this.call('/v1/client/tickets/exchange', {
+                method: 'POST',
+                body: JSON.stringify({ attempt_id: result.attemptId, ticket: result.ticket }),
+            }).catch(() => undefined);
+        }
+        if (result) {
+            window.history.replaceState({}, document.title, stripRedirectParams(window.location.href));
+        }
+        await this.reload();
+    }
+    readPendingAttempt() {
+        const result = readRedirectResult(window.location.search);
+        return result?.status && !result.ticket
+            ? { id: result.attemptId, status: result.status }
+            : null;
+    }
+    call(path, init) {
+        return this.doFetch(`${this.baseUrl}${path}`, {
+            ...init,
+            // Cookies carry the session; a request without this is indistinguishable
+            // from being signed out.
+            credentials: 'include',
+            headers: {
+                'x-publishable-key': this.publishableKey,
+                ...(init?.body ? { 'content-type': 'application/json' } : {}),
+                ...init?.headers,
+            },
+        });
+    }
+    applyToken(jwt, sessionId) {
+        const expiresAt = readExpiry(jwt);
+        if (!expiresAt)
+            return;
+        this.cache.set({ jwt, expiresAt, sessionId });
+        this._claims.next(decodeClaims(jwt));
+    }
+    async refresh() {
+        const current = this.cache.peek();
+        if (!current)
+            return;
+        try {
+            const response = await this.call(`/v1/client/sessions/${current.sessionId}/tokens`, {
+                method: 'POST',
+            });
+            if (!response.ok)
+                throw new Error('refresh failed');
+            const body = (await response.json());
+            this.applyToken(body.jwt, body.session_id);
+            this.scheduleRefresh();
+        }
+        catch {
+            // The session may genuinely be gone. Re-boot rather than guess.
+            await this.reload();
+        }
+    }
+    /** §7.4: proactive, jittered refresh scheduled from the token's own expiry. */
+    scheduleRefresh() {
+        this.clearRefreshTimer();
+        if (this._status.value !== 'signed_in')
+            return;
+        const token = this.cache.peek();
+        if (!token)
+            return;
+        const delay = msUntilRefresh({ token, now: Date.now() });
+        this.refreshTimer = setTimeout(() => void this.refresh(), delay);
+    }
+    clearRefreshTimer() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+/** Decode a JWT payload without verifying it — a scheduling/UI hint only. */
+function decodeClaims(jwt) {
+    const parts = jwt.split('.');
+    if (parts.length !== 3)
+        return null;
+    try {
+        return JSON.parse(atob(parts[1].replace(/-/g, '+').replace(/_/g, '/')));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"atlas.service.js","sourceRoot":"","sources":["../../../src/lib/atlas.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Injectable,\n  OnDestroy,\n  PLATFORM_ID,\n  Signal,\n  computed,\n  inject,\n} from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { BehaviorSubject, Observable, combineLatest } from 'rxjs';\nimport { distinctUntilChanged, map } from 'rxjs/operators';\nimport {\n  FapiClient,\n  TokenCache,\n  getProviderToken as fetchProviderToken,\n  msUntilRefresh,\n  readExpiry,\n  readRedirectResult,\n  stripRedirectParams,\n  type ProviderToken,\n} from '@atlasauth/js';\nimport { evaluate, type ProtectCondition } from '@atlasauth/authz';\nimport { ATLAS_OPTIONS } from './atlas.config';\nimport { cssVariables, resolveTokens, type Appearance } from './appearance';\nimport { EN_US, withFallback, type Catalog } from './i18n';\nimport type {\n  AtlasOrganizationMembership,\n  AtlasSession,\n  AtlasUser,\n  AuthStatus,\n  SessionClaims,\n} from './types';\n\n/**\n * `AtlasService` — the Angular peer of React's `<AtlasProvider>` + hooks.\n *\n * It holds exactly one thing that matters in memory: the short-lived JWT, in a\n * {@link TokenCache}. Not localStorage, not a cookie this code writes — the\n * refresh token is HttpOnly so browser script never touches it, and the JWT\n * lives only as long as the tab. Anything persisted would survive the tab and\n * become the first thing an XSS reads.\n *\n * Reactive auth state is exposed two ways so callers can pick their idiom:\n *  - RxJS observables (`user$`, `session$`, `isSignedIn$`, …) — the primary API,\n *    the analogue of the React hooks' return values.\n *  - Angular signals (`user`, `session`, `isSignedIn`, …) — the same values as\n *    `Signal<T>`, for templates and `computed()`.\n *\n * The imperative methods (`signOut`, `getToken`, `getProviderToken`,\n * `setActiveOrganization`, `reload`) mirror the actions the hooks return.\n */\n@Injectable({ providedIn: 'root' })\nexport class AtlasService implements OnDestroy {\n  private readonly options = inject(ATLAS_OPTIONS);\n  private readonly platformId = inject(PLATFORM_ID);\n  private readonly isBrowser = isPlatformBrowser(this.platformId);\n\n  private readonly baseUrl: string;\n  private readonly publishableKey: string;\n  private readonly doFetch: typeof fetch;\n\n  private readonly cache = new TokenCache();\n  private readonly fapiClient: FapiClient;\n  private refreshTimer: ReturnType<typeof setTimeout> | null = null;\n\n  private readonly catalog: Catalog;\n\n  /**\n   * A sign-in attempt handed back by an OAuth redirect that still needs a second\n   * factor (no session was issued). Null in the ordinary case; the `<atlas-sign-in>`\n   * flow seeds itself from this so the user resumes at the 2FA step. Captured\n   * once, synchronously, at construction — before any flow component reads it.\n   */\n  readonly pendingAttempt: { id: string; status: string } | null;\n\n  // --- Reactive state (source of truth) ---------------------------------------\n\n  private readonly _status = new BehaviorSubject<AuthStatus>('loading');\n  private readonly _user = new BehaviorSubject<AtlasUser | null>(null);\n  private readonly _session = new BehaviorSubject<AtlasSession | null>(null);\n  private readonly _claims = new BehaviorSubject<SessionClaims | null>(null);\n  private readonly _memberships = new BehaviorSubject<AtlasOrganizationMembership[]>([]);\n\n  /** The three-state auth lifecycle: `loading` → `signed_in` | `signed_out`. */\n  readonly status$: Observable<AuthStatus> = this._status.asObservable();\n  readonly user$: Observable<AtlasUser | null> = this._user.asObservable();\n  readonly session$: Observable<AtlasSession | null> = this._session.asObservable();\n  readonly claims$: Observable<SessionClaims | null> = this._claims.asObservable();\n  readonly memberships$: Observable<AtlasOrganizationMembership[]> =\n    this._memberships.asObservable();\n\n  /**\n   * True once the SDK has finished its first boot. Distinguishing \"still loading\"\n   * from \"signed out\" is what lets a template avoid the flash of a sign-in form\n   * on every page load.\n   */\n  readonly isLoaded$: Observable<boolean> = this.status$.pipe(\n    map((s) => s !== 'loading'),\n    distinctUntilChanged(),\n  );\n\n  readonly isSignedIn$: Observable<boolean> = this.status$.pipe(\n    map((s) => s === 'signed_in'),\n    distinctUntilChanged(),\n  );\n\n  /** The active organization membership, derived from the token's `org_id` claim. */\n  readonly organization$: Observable<AtlasOrganizationMembership | null> = combineLatest([\n    this._memberships,\n    this._claims,\n  ]).pipe(\n    map(\n      ([memberships, claims]) =>\n        memberships.find((m) => m.organization.id === claims?.org_id) ?? null,\n    ),\n  );\n\n  // --- Signal mirror ----------------------------------------------------------\n\n  readonly status: Signal<AuthStatus> = toSignal(this.status$, { initialValue: 'loading' });\n  readonly user: Signal<AtlasUser | null> = toSignal(this.user$, { initialValue: null });\n  readonly session: Signal<AtlasSession | null> = toSignal(this.session$, { initialValue: null });\n  readonly claims: Signal<SessionClaims | null> = toSignal(this.claims$, { initialValue: null });\n  readonly memberships: Signal<AtlasOrganizationMembership[]> = toSignal(this.memberships$, {\n    initialValue: [] as AtlasOrganizationMembership[],\n  });\n  readonly isLoaded: Signal<boolean> = computed(() => this.status() !== 'loading');\n  readonly isSignedIn: Signal<boolean> = computed(() => this.status() === 'signed_in');\n  readonly organization: Signal<AtlasOrganizationMembership | null> = computed(() => {\n    const orgId = this.claims()?.org_id;\n    return this.memberships().find((m) => m.organization.id === orgId) ?? null;\n  });\n\n  constructor() {\n    const options = this.options;\n    this.publishableKey = options.publishableKey;\n    this.baseUrl = options.frontendApi ?? '';\n    this.doFetch = options.fetchImpl ?? ((...args: Parameters<typeof fetch>) => fetch(...args));\n\n    this.catalog = options.localization ? withFallback(options.localization) : EN_US;\n\n    this.fapiClient = new FapiClient({\n      publishableKey: this.publishableKey,\n      baseUrl: this.baseUrl,\n      fetchImpl: this.doFetch,\n    });\n\n    // Captured synchronously (not in an async init) so it is available before any\n    // flow component reads it: a needs_second_factor redirect carries a status but\n    // no ticket, and that is what the 2FA resume seeds from.\n    this.pendingAttempt = this.isBrowser ? this.readPendingAttempt() : null;\n\n    // Boot once, browser only. On the server there is no cookie jar to read a\n    // session from, so we leave the state at `loading` and let hydration boot it.\n    if (this.isBrowser) {\n      void this.boot();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.clearRefreshTimer();\n    this._status.complete();\n    this._user.complete();\n    this._session.complete();\n    this._claims.complete();\n    this._memberships.complete();\n  }\n\n  // --- Configuration accessors ------------------------------------------------\n\n  get appearance(): Appearance | undefined {\n    return this.options.appearance;\n  }\n\n  get localization(): Catalog {\n    return this.catalog;\n  }\n\n  get frontendApi(): string {\n    return this.baseUrl;\n  }\n\n  /** Tokens as CSS custom properties, for a host element to inherit. */\n  appearanceVariables(): Record<string, string> {\n    return cssVariables(resolveTokens(this.options.appearance));\n  }\n\n  /** A fresh {@link FapiClient} for driving a sign-in/sign-up flow. */\n  createFapiClient(): FapiClient {\n    return new FapiClient({ publishableKey: this.publishableKey, baseUrl: this.baseUrl });\n  }\n\n  // --- Imperative API (mirrors the React hooks' actions) ----------------------\n\n  /**\n   * The current session's JWT, always fresh: if the cached token is within 5s of\n   * expiry it is refreshed first rather than handed over. Null when signed out.\n   */\n  async getToken(): Promise<string | null> {\n    const usable = this.cache.get(5_000);\n    if (usable) return usable.jwt;\n\n    await this.refresh();\n    return this.cache.get(5_000)?.jwt ?? null;\n  }\n\n  /**\n   * The signed-in user's OWN live access token at a connected provider (Google,\n   * GitHub, …), so the app can call that provider's API from the browser. Null\n   * when there is no usable token — no linked account, or the provider granted /\n   * kept none. The server refreshes a stale token on read; the refresh token is\n   * never exposed.\n   */\n  getProviderToken(provider: string): Promise<ProviderToken | null> {\n    return fetchProviderToken(this.fapiClient, provider);\n  }\n\n  /** Imperative `has()` — the same evaluation `*atlasProtect` renders on. */\n  has(condition: ProtectCondition): boolean {\n    return evaluate(this._claims.value, condition).allowed;\n  }\n\n  /** Revoke the current session server-side and drop all local auth state. */\n  async signOut(): Promise<void> {\n    const current = this.cache.peek();\n    if (current) {\n      await this.call(`/v1/client/sessions/${current.sessionId}/revoke`, {\n        method: 'POST',\n      }).catch(() => undefined);\n    }\n    this.clearRefreshTimer();\n    this.cache.clear();\n    this._status.next('signed_out');\n    this._user.next(null);\n    this._session.next(null);\n    this._claims.next(null);\n    this._memberships.next([]);\n  }\n\n  /**\n   * Switch the active organization (or `null` for the personal account). The\n   * new token carries the new org claims, so the app's permission checks update\n   * without a re-login.\n   */\n  async setActiveOrganization(organizationId: string | null): Promise<void> {\n    const current = this.cache.peek();\n    if (!current) return;\n\n    const response = await this.call(`/v1/client/sessions/${current.sessionId}/touch`, {\n      method: 'POST',\n      body: JSON.stringify({ active_organization_id: organizationId }),\n    });\n    if (!response.ok) return;\n\n    const body = (await response.json()) as { jwt: string };\n    this.applyToken(body.jwt, current.sessionId);\n    await this.reload();\n  }\n\n  /** Re-read `/v1/client`: refresh user, session, memberships and status. */\n  async reload(): Promise<void> {\n    try {\n      const response = await this.call('/v1/client');\n      if (!response.ok) throw new Error('boot failed');\n\n      const body = (await response.json()) as {\n        session: AtlasSession | null;\n        user: AtlasUser | null;\n        jwt?: string;\n        organization_memberships?: AtlasOrganizationMembership[];\n      };\n\n      if (!body.session || !body.user) {\n        this.clearRefreshTimer();\n        this.cache.clear();\n        this._status.next('signed_out');\n        this._user.next(null);\n        this._session.next(null);\n        this._claims.next(null);\n        this._memberships.next([]);\n        return;\n      }\n\n      this._user.next(body.user);\n      this._session.next(body.session);\n      this._memberships.next(body.organization_memberships ?? []);\n      if (body.jwt) this.applyToken(body.jwt, body.session.id);\n      this._status.next('signed_in');\n      this.scheduleRefresh();\n    } catch {\n      // A failed boot is NOT signed-out. Rendering a sign-in form because the\n      // network hiccuped throws away a perfectly good session and forces a\n      // needless re-authentication. Only promote loading → signed_out.\n      if (this._status.value === 'loading') this._status.next('signed_out');\n    }\n  }\n\n  // --- Internals --------------------------------------------------------------\n\n  /**\n   * §6.3 step 3: complete a redirect-based sign-in, then boot. An OAuth or\n   * hosted-page flow lands back with a one-time ticket in the URL; exchange it\n   * for cookies, scrub the URL so a reload cannot replay it, THEN read the\n   * session. A redirect carrying only a status (a second factor is still owed)\n   * has no ticket, so nothing is exchanged and the app boots signed-out.\n   */\n  private async boot(): Promise<void> {\n    const result = readRedirectResult(window.location.search);\n\n    if (result?.ticket) {\n      await this.call('/v1/client/tickets/exchange', {\n        method: 'POST',\n        body: JSON.stringify({ attempt_id: result.attemptId, ticket: result.ticket }),\n      }).catch(() => undefined);\n    }\n    if (result) {\n      window.history.replaceState({}, document.title, stripRedirectParams(window.location.href));\n    }\n    await this.reload();\n  }\n\n  private readPendingAttempt(): { id: string; status: string } | null {\n    const result = readRedirectResult(window.location.search);\n    return result?.status && !result.ticket\n      ? { id: result.attemptId, status: result.status }\n      : null;\n  }\n\n  private call(path: string, init?: RequestInit): Promise<Response> {\n    return this.doFetch(`${this.baseUrl}${path}`, {\n      ...init,\n      // Cookies carry the session; a request without this is indistinguishable\n      // from being signed out.\n      credentials: 'include',\n      headers: {\n        'x-publishable-key': this.publishableKey,\n        ...(init?.body ? { 'content-type': 'application/json' } : {}),\n        ...init?.headers,\n      },\n    });\n  }\n\n  private applyToken(jwt: string, sessionId: string): void {\n    const expiresAt = readExpiry(jwt);\n    if (!expiresAt) return;\n\n    this.cache.set({ jwt, expiresAt, sessionId });\n    this._claims.next(decodeClaims(jwt));\n  }\n\n  private async refresh(): Promise<void> {\n    const current = this.cache.peek();\n    if (!current) return;\n\n    try {\n      const response = await this.call(`/v1/client/sessions/${current.sessionId}/tokens`, {\n        method: 'POST',\n      });\n      if (!response.ok) throw new Error('refresh failed');\n\n      const body = (await response.json()) as { jwt: string; session_id: string };\n      this.applyToken(body.jwt, body.session_id);\n      this.scheduleRefresh();\n    } catch {\n      // The session may genuinely be gone. Re-boot rather than guess.\n      await this.reload();\n    }\n  }\n\n  /** §7.4: proactive, jittered refresh scheduled from the token's own expiry. */\n  private scheduleRefresh(): void {\n    this.clearRefreshTimer();\n    if (this._status.value !== 'signed_in') return;\n\n    const token = this.cache.peek();\n    if (!token) return;\n\n    const delay = msUntilRefresh({ token, now: Date.now() });\n    this.refreshTimer = setTimeout(() => void this.refresh(), delay);\n  }\n\n  private clearRefreshTimer(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer);\n      this.refreshTimer = null;\n    }\n  }\n}\n\n/** Decode a JWT payload without verifying it — a scheduling/UI hint only. */\nfunction decodeClaims(jwt: string): SessionClaims | null {\n  const parts = jwt.split('.');\n  if (parts.length !== 3) return null;\n  try {\n    return JSON.parse(\n      atob(parts[1]!.replace(/-/g, '+').replace(/_/g, '/')),\n    ) as SessionClaims;\n  } catch {\n    return null;\n  }\n}\n"]}

package/dist/esm2022/lib/atlas.ui.mjs

@@ -0,0 +1,36 @@
+import { AtlasSignedInDirective } from './directives/signed-in.directive';
+import { AtlasSignedOutDirective } from './directives/signed-out.directive';
+import { AtlasLoadingDirective } from './directives/loading.directive';
+import { AtlasLoadedDirective } from './directives/loaded.directive';
+import { AtlasProtectDirective } from './directives/protect.directive';
+import { AtlasRootDirective } from './directives/atlas-root.directive';
+import { SignInComponent } from './components/sign-in.component';
+import { SignUpComponent } from './components/sign-up.component';
+import { UserButtonComponent } from './components/user-button.component';
+import { OrganizationSwitcherComponent } from './components/organization-switcher.component';
+import { UserProfileComponent } from './components/user-profile.component';
+import { OrganizationProfileComponent } from './components/organization-profile.component';
+/**
+ * Every standalone directive and component the SDK ships. Import the array in a
+ * standalone component's `imports`, or rely on `AtlasModule` re-exporting it for
+ * NgModule-based apps:
+ *
+ * ```ts
+ * @Component({ standalone: true, imports: [...ATLAS_UI], template: '…' })
+ * ```
+ */
+export const ATLAS_UI = [
+    AtlasSignedInDirective,
+    AtlasSignedOutDirective,
+    AtlasLoadingDirective,
+    AtlasLoadedDirective,
+    AtlasProtectDirective,
+    AtlasRootDirective,
+    SignInComponent,
+    SignUpComponent,
+    UserButtonComponent,
+    OrganizationSwitcherComponent,
+    UserProfileComponent,
+    OrganizationProfileComponent,
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXRsYXMudWkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2F0bGFzLnVpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQzFFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3JFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNqRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDakUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDekUsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sOENBQThDLENBQUM7QUFDN0YsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDM0UsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFFM0Y7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUc7SUFDdEIsc0JBQXNCO0lBQ3RCLHVCQUF1QjtJQUN2QixxQkFBcUI7SUFDckIsb0JBQW9CO0lBQ3BCLHFCQUFxQjtJQUNyQixrQkFBa0I7SUFDbEIsZUFBZTtJQUNmLGVBQWU7SUFDZixtQkFBbUI7SUFDbkIsNkJBQTZCO0lBQzdCLG9CQUFvQjtJQUNwQiw0QkFBNEI7Q0FDcEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEF0bGFzU2lnbmVkSW5EaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMvc2lnbmVkLWluLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBBdGxhc1NpZ25lZE91dERpcmVjdGl2ZSB9IGZyb20gJy4vZGlyZWN0aXZlcy9zaWduZWQtb3V0LmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBBdGxhc0xvYWRpbmdEaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMvbG9hZGluZy5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgQXRsYXNMb2FkZWREaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMvbG9hZGVkLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBBdGxhc1Byb3RlY3REaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMvcHJvdGVjdC5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgQXRsYXNSb290RGlyZWN0aXZlIH0gZnJvbSAnLi9kaXJlY3RpdmVzL2F0bGFzLXJvb3QuZGlyZWN0aXZlJztcbmltcG9ydCB7IFNpZ25JbkNvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9zaWduLWluLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBTaWduVXBDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvc2lnbi11cC5jb21wb25lbnQnO1xuaW1wb3J0IHsgVXNlckJ1dHRvbkNvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy91c2VyLWJ1dHRvbi5jb21wb25lbnQnO1xuaW1wb3J0IHsgT3JnYW5pemF0aW9uU3dpdGNoZXJDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvb3JnYW5pemF0aW9uLXN3aXRjaGVyLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBVc2VyUHJvZmlsZUNvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy91c2VyLXByb2ZpbGUuY29tcG9uZW50JztcbmltcG9ydCB7IE9yZ2FuaXphdGlvblByb2ZpbGVDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvb3JnYW5pemF0aW9uLXByb2ZpbGUuY29tcG9uZW50JztcblxuLyoqXG4gKiBFdmVyeSBzdGFuZGFsb25lIGRpcmVjdGl2ZSBhbmQgY29tcG9uZW50IHRoZSBTREsgc2hpcHMuIEltcG9ydCB0aGUgYXJyYXkgaW4gYVxuICogc3RhbmRhbG9uZSBjb21wb25lbnQncyBgaW1wb3J0c2AsIG9yIHJlbHkgb24gYEF0bGFzTW9kdWxlYCByZS1leHBvcnRpbmcgaXQgZm9yXG4gKiBOZ01vZHVsZS1iYXNlZCBhcHBzOlxuICpcbiAqIGBgYHRzXG4gKiBAQ29tcG9uZW50KHsgc3RhbmRhbG9uZTogdHJ1ZSwgaW1wb3J0czogWy4uLkFUTEFTX1VJXSwgdGVtcGxhdGU6ICfigKYnIH0pXG4gKiBgYGBcbiAqL1xuZXhwb3J0IGNvbnN0IEFUTEFTX1VJID0gW1xuICBBdGxhc1NpZ25lZEluRGlyZWN0aXZlLFxuICBBdGxhc1NpZ25lZE91dERpcmVjdGl2ZSxcbiAgQXRsYXNMb2FkaW5nRGlyZWN0aXZlLFxuICBBdGxhc0xvYWRlZERpcmVjdGl2ZSxcbiAgQXRsYXNQcm90ZWN0RGlyZWN0aXZlLFxuICBBdGxhc1Jvb3REaXJlY3RpdmUsXG4gIFNpZ25JbkNvbXBvbmVudCxcbiAgU2lnblVwQ29tcG9uZW50LFxuICBVc2VyQnV0dG9uQ29tcG9uZW50LFxuICBPcmdhbml6YXRpb25Td2l0Y2hlckNvbXBvbmVudCxcbiAgVXNlclByb2ZpbGVDb21wb25lbnQsXG4gIE9yZ2FuaXphdGlvblByb2ZpbGVDb21wb25lbnQsXG5dIGFzIGNvbnN0O1xuIl19

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

@@ -0,0 +1,180 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, inject, } from '@angular/core';
+import { nextStep } from '@atlasauth/js';
+import { AtlasService } from '../atlas.service';
+import { classFor } from '../appearance';
+import { translate } from '../i18n';
+import * as i0 from "@angular/core";
+/**
+ * The server-driven flow shell, shared by `<atlas-sign-in>` and
+ * `<atlas-sign-up>`. The Angular peer of React's internal `AttemptFlow`.
+ *
+ * It contains NO decision about what comes next: it renders whatever `status`
+ * the server returned, mapped through `nextStep` from `@atlasauth/js` (the same
+ * exhaustive mapping the React SDK uses), so adding a step is a server change
+ * and an out-of-date client degrades to a visible "please update" message rather
+ * than a blank screen.
+ */
+export class AttemptFlowComponent {
+    atlas = inject(AtlasService);
+    attempt = null;
+    busy = false;
+    errors = [];
+    titleKey = 'signIn.title';
+    /** Emits the collected field values when the form is submitted. */
+    submitFlow = new EventEmitter();
+    values = {};
+    t(key, vars) {
+        return translate(this.atlas.localization, key, vars);
+    }
+    cls(key, base) {
+        return classFor(key, this.atlas.appearance, base);
+    }
+    setValue(name, value) {
+        this.values = { ...this.values, [name]: value };
+    }
+    onSubmit(event) {
+        event.preventDefault();
+        this.submitFlow.emit(this.values);
+    }
+    formErrors() {
+        return this.errors.filter((error) => !error.param);
+    }
+    fieldErrorsFor(name) {
+        return this.errors.filter((error) => error.param === name);
+    }
+    step() {
+        return this.attempt ? nextStep(this.attempt) : { kind: 'collect_identifier' };
+    }
+    showSubmit() {
+        const kind = this.step().kind;
+        return kind !== 'done' && kind !== 'await_oauth';
+    }
+    fields() {
+        const step = this.step();
+        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_second_factor':
+                return [{ kind: 'input', name: 'code', labelKey: 'mfa.codeLabel', type: 'text' }];
+            case 'enroll_second_factor':
+                // Two consecutive codes (§5.6): a phone with a fast clock fails here
+                // rather than on every sign-in afterwards.
+                return [
+                    { kind: 'input', name: 'code', labelKey: 'mfa.enrollFirstCodeLabel', type: 'text' },
+                    { kind: 'input', name: 'secondCode', labelKey: 'mfa.enrollSecondCodeLabel', type: 'text' },
+                ];
+            case 'collect_email_code':
+                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 'await_oauth':
+                return [msg('signIn.magicLinkSent')];
+            case 'done':
+                return [msg('signIn.checkOtherTab')];
+            case 'restart':
+                return [msg('error.generic')];
+            default:
+                // A status this SDK version does not know. An honest message beats a
+                // blank login box the user cannot act on.
+                return [msg('error.generic')];
+        }
+    }
+    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: `
+    <div [class]="cls('card', 'atlas-card')">
+      <h1 [class]="cls('headerTitle', 'atlas-title')">{{ t(titleKey) }}</h1>
+
+      @for (error of formErrors(); track error.code) {
+        <p [class]="cls('formFieldError', 'atlas-error')" role="alert">{{ error.message }}</p>
+      }
+
+      <form (submit)="onSubmit($event)">
+        @for (f of fields(); track $index) {
+          @if (f.kind === 'input') {
+            <label class="atlas-field">
+              <span>{{ t(f.labelKey) }}</span>
+              <input
+                [class]="cls('formFieldInput', 'atlas-input')"
+                [type]="f.type"
+                [value]="values[f.name] ?? ''"
+                (input)="setValue(f.name, $any($event.target).value)"
+              />
+              @for (error of fieldErrorsFor(f.name); track error.code) {
+                <span [class]="cls('formFieldError', 'atlas-error')">{{ error.message }}</span>
+              }
+            </label>
+          } @else {
+            <p>{{ t(f.labelKey) }}</p>
+          }
+        }
+
+        @if (showSubmit()) {
+          <button [class]="cls('formButtonPrimary', 'atlas-button')" [disabled]="busy" type="submit">
+            {{ t('signIn.submit') }}
+          </button>
+        }
+      </form>
+    </div>
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AttemptFlowComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'atlas-attempt-flow',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <div [class]="cls('card', 'atlas-card')">
+      <h1 [class]="cls('headerTitle', 'atlas-title')">{{ t(titleKey) }}</h1>
+
+      @for (error of formErrors(); track error.code) {
+        <p [class]="cls('formFieldError', 'atlas-error')" role="alert">{{ error.message }}</p>
+      }
+
+      <form (submit)="onSubmit($event)">
+        @for (f of fields(); track $index) {
+          @if (f.kind === 'input') {
+            <label class="atlas-field">
+              <span>{{ t(f.labelKey) }}</span>
+              <input
+                [class]="cls('formFieldInput', 'atlas-input')"
+                [type]="f.type"
+                [value]="values[f.name] ?? ''"
+                (input)="setValue(f.name, $any($event.target).value)"
+              />
+              @for (error of fieldErrorsFor(f.name); track error.code) {
+                <span [class]="cls('formFieldError', 'atlas-error')">{{ error.message }}</span>
+              }
+            </label>
+          } @else {
+            <p>{{ t(f.labelKey) }}</p>
+          }
+        }
+
+        @if (showSubmit()) {
+          <button [class]="cls('formButtonPrimary', 'atlas-button')" [disabled]="busy" type="submit">
+            {{ t('signIn.submit') }}
+          </button>
+        }
+      </form>
+    </div>
+  `,
+                }]
+        }], propDecorators: { attempt: [{
+                type: Input
+            }], busy: [{
+                type: Input
+            }], errors: [{
+                type: Input
+            }], titleKey: [{
+                type: Input
+            }], submitFlow: [{
+                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"]}