@newheap/platform-common 1.3.0 → 1.4.0

package/two-factor/i18n/nl.json

@@ -0,0 +1,93 @@
+{
+  "nh-two-factor": {
+    "required": "Voer een code in om het aanmelden af te ronden.",
+    "enrollment-required": "Stel tweestapsverificatie in om verder te gaan.",
+    "invalid-code": "De code is ongeldig. Probeer de volgende code.",
+    "challenge-expired": "De aanmelding is verlopen. Meld je opnieuw aan.",
+    "locked-out": "Te veel pogingen. Het account is tijdelijk geblokkeerd.",
+    "method-not-allowed": "Deze methode kan niet voor dit account worden gebruikt.",
+    "not-enabled": "Tweestapsverificatie staat niet aan.",
+    "already-enabled": "Tweestapsverificatie staat al aan.",
+    "setup-not-started": "Start eerst het instellen.",
+    "reauthentication-required": "Bevestig je wachtwoord of een code om door te gaan.",
+    "reauthentication-failed": "Het wachtwoord of de code klopt niet.",
+    "required-by-policy": "Je organisatie vereist tweestapsverificatie.",
+    "not-allowed-while-impersonating": "Je kunt tweestapsverificatie niet wijzigen tijdens impersonatie.",
+    "configuration-invalid": "Tweestapsverificatie is niet goed geconfigureerd.",
+    "email-cooldown": "Wacht even voordat je een nieuwe code aanvraagt.",
+    "email-unavailable": "Er is geen bevestigd e-mailadres beschikbaar.",
+    "user-not-found": "De gebruiker is niet gevonden.",
+    "passkey-invalid": "De passkey kon niet worden gecontroleerd.",
+    "passkey-not-found": "De passkey is niet gevonden.",
+    "passkey-unavailable": "De passkey-vraag is geannuleerd, of deze browser ondersteunt geen passkeys.",
+    "ui": {
+      "error": "Er ging iets mis. Probeer het opnieuw.",
+      "challenge-title": "Tweestapsverificatie",
+      "settings-title": "Tweestapsverificatie",
+      "enrollment-title": "Tweestapsverificatie instellen",
+      "enrollment-instructions": "Je organisatie vereist een tweede stap bij het aanmelden. Kies hoe je wilt bevestigen dat jij het bent.",
+      "method-label": "Verificatiemethode",
+      "method": {
+        "authenticator": "Authenticator-app",
+        "recovery-code": "Herstelcode",
+        "email": "E-mailcode",
+        "passkey": "Passkey"
+      },
+      "code-label": {
+        "authenticator": "Code uit je authenticator-app",
+        "recovery-code": "Herstelcode",
+        "email": "Code uit de e-mail"
+      },
+      "verify": "Controleren",
+      "verifying": "Bezig met controleren…",
+      "cancel": "Annuleren",
+      "remember-device": "Dit apparaat onthouden",
+      "send-email-code": "Stuur mij een code",
+      "resend-email-code": "Stuur een nieuwe code",
+      "email-code-sent": "We hebben een code gemaild. De code verloopt om {{time}}.",
+      "use-passkey": "Passkey gebruiken",
+      "passkey-verify-instructions": "Je browser vraagt je te bevestigen met een passkey op dit apparaat, je telefoon of een beveiligingssleutel.",
+      "sign-in-with-passkey": "Aanmelden met een passkey",
+      "authenticator-instructions": "Scan de QR-code met je authenticator-app, of voer de sleutel handmatig in. Voer daarna de code in die de app toont.",
+      "shared-key": "Sleutel",
+      "qr-code-alt": "QR-code voor je authenticator-app",
+      "confirm": "Bevestigen",
+      "email-instructions": "We sturen een code naar je bevestigde e-mailadres.",
+      "passkey-instructions": "Maak een passkey met de schermvergrendeling van dit apparaat, een wachtwoordmanager of een beveiligingssleutel.",
+      "passkey-name": "Naam van de passkey",
+      "create-passkey": "Passkey maken",
+      "recovery-codes-title": "Herstelcodes",
+      "recovery-codes-instructions": "Bewaar deze codes op een veilige plek. Met elke code kun je je één keer aanmelden als je je andere methodes niet kunt gebruiken. Ze worden alleen nu getoond.",
+      "copy": "Kopiëren",
+      "copied": "Gekopieerd",
+      "download": "Downloaden",
+      "recovery-codes-saved": "Ik heb deze codes bewaard",
+      "continue": "Doorgaan",
+      "loading": "Laden…",
+      "status-enabled": "Aan",
+      "status-disabled": "Uit",
+      "status-required": "Vereist door je organisatie",
+      "recovery-codes-left": "Nog {{count}} herstelcodes",
+      "set-up-authenticator": "Authenticator-app instellen",
+      "change-authenticator": "Authenticator-app wijzigen",
+      "set-up-email": "E-mailcodes gebruiken",
+      "passkeys-title": "Passkeys",
+      "no-passkeys": "Nog geen passkeys.",
+      "add-passkey": "Passkey toevoegen",
+      "rename": "Naam wijzigen",
+      "save": "Opslaan",
+      "remove": "Verwijderen",
+      "passkey-created": "Toegevoegd op {{date}}",
+      "passkey-synced": "Gesynchroniseerd",
+      "regenerate-recovery-codes": "Nieuwe herstelcodes maken",
+      "forget-devices": "Onthouden apparaten vergeten",
+      "disable": "Tweestapsverificatie uitzetten",
+      "reauthentication-title": "Bevestig dat jij het bent",
+      "reauthentication-method": "Bevestigen met",
+      "password": "Wachtwoord",
+      "devices-forgotten": "Elk apparaat vraagt weer om de tweede stap.",
+      "session-renewed": "Je andere sessies zijn afgemeld.",
+      "change-saved": "Je wijziging is opgeslagen."
+    }
+  }
+}

package/two-factor/index.d.ts

@@ -0,0 +1,261 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, EnvironmentProviders } from '@angular/core';
+import * as _newheap_platform_common from '@newheap/platform-common';
+import { TaskResult, NhTwoFactorChallenge, INhAuthorization, NhTwoFactorEmailCodeSent, NhTwoFactorEnrollmentResult, NhAuthenticatorSetup, NhTwoFactorStatus, NhPasskey, NhAuthenticationStep } from '@newheap/platform-common';
+import { TranslationObject } from '@ngx-translate/core';
+
+/**
+ * Returns the translation keys for a failed two-factor result. Two-factor failure codes map
+ * to `nh-two-factor.<suffix>`; other failures use a generic message.
+ */
+declare function nhTwoFactorErrorKeys(result: TaskResult<unknown>): string[];
+/**
+ * Whether the server ended the pending sign-in step, so the user has to sign in again.
+ */
+declare function nhTwoFactorStepEnded(result: TaskResult<unknown>): boolean;
+/** Reads the value of the input that raised an event. */
+declare function nhTwoFactorInputValue(event: Event): string;
+/** Reads the checked state of the checkbox that raised an event. */
+declare function nhTwoFactorInputChecked(event: Event): boolean;
+
+/**
+ * Completes a second-factor challenge with a code, an e-mailed code, a recovery code or a
+ * passkey. The session is stored by the auth service before `authenticated` emits.
+ */
+declare class NhTwoFactorChallengeComponent {
+    private readonly auth;
+    private readonly injector;
+    private readonly codeInput;
+    /** The pending challenge from the login response. */
+    readonly challenge: _angular_core.InputSignal<NhTwoFactorChallenge>;
+    /** Whether to offer "remember this device" when the server allows it for this challenge. */
+    readonly allowRememberDevice: _angular_core.InputSignal<boolean>;
+    readonly authenticated: _angular_core.OutputEmitterRef<INhAuthorization>;
+    /** The challenge expired or the account was locked; the user has to sign in again. */
+    readonly expired: _angular_core.OutputEmitterRef<void>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    readonly id: string;
+    readonly passkeySupported: boolean;
+    readonly selectedMethod: _angular_core.WritableSignal<string | null>;
+    readonly code: _angular_core.WritableSignal<string>;
+    readonly rememberDevice: _angular_core.WritableSignal<boolean>;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly errorKeys: _angular_core.WritableSignal<string[]>;
+    readonly emailSent: _angular_core.WritableSignal<NhTwoFactorEmailCodeSent | null>;
+    readonly methods: _angular_core.Signal<string[]>;
+    readonly method: _angular_core.Signal<string>;
+    readonly usesCode: _angular_core.Signal<boolean>;
+    readonly numericCode: _angular_core.Signal<boolean>;
+    readonly offerRememberDevice: _angular_core.Signal<boolean>;
+    readonly value: typeof nhTwoFactorInputValue;
+    readonly checked: typeof nhTwoFactorInputChecked;
+    constructor();
+    selectMethod(method: string): void;
+    verify(): Promise<void>;
+    sendEmailCode(): Promise<void>;
+    private run;
+    private fail;
+    private defaultMethod;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhTwoFactorChallengeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhTwoFactorChallengeComponent, "nh-two-factor-challenge", never, { "challenge": { "alias": "challenge"; "required": true; "isSignal": true; }; "allowRememberDevice": { "alias": "allowRememberDevice"; "required": false; "isSignal": true; }; }, { "authenticated": "authenticated"; "expired": "expired"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/**
+ * Enrolls a second factor for a user whom the policy requires to use one, during sign-in.
+ * The session is stored by the auth service; `completed` emits after the user saved the
+ * recovery codes.
+ */
+declare class NhTwoFactorEnrollmentComponent implements OnInit {
+    private readonly auth;
+    private readonly injector;
+    private readonly codeInput;
+    /** The enrollment step from the login response (status `enrollment-required`). */
+    readonly enrollment: _angular_core.InputSignal<NhTwoFactorChallenge>;
+    readonly completed: _angular_core.OutputEmitterRef<NhTwoFactorEnrollmentResult<_newheap_platform_common.INhAuthorization>>;
+    /** The enrollment expired or the account was locked; the user has to sign in again. */
+    readonly expired: _angular_core.OutputEmitterRef<void>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    readonly id: string;
+    readonly passkeySupported: boolean;
+    readonly selectedMethod: _angular_core.WritableSignal<string | null>;
+    readonly setup: _angular_core.WritableSignal<NhAuthenticatorSetup | null>;
+    readonly emailSent: _angular_core.WritableSignal<NhTwoFactorEmailCodeSent | null>;
+    readonly code: _angular_core.WritableSignal<string>;
+    readonly passkeyName: _angular_core.WritableSignal<string>;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly errorKeys: _angular_core.WritableSignal<string[]>;
+    readonly result: _angular_core.WritableSignal<NhTwoFactorEnrollmentResult<_newheap_platform_common.INhAuthorization> | null>;
+    readonly methods: _angular_core.Signal<string[]>;
+    readonly method: _angular_core.Signal<string>;
+    readonly value: typeof nhTwoFactorInputValue;
+    constructor();
+    ngOnInit(): void;
+    selectMethod(method: string): void;
+    startAuthenticator(): Promise<void>;
+    sendEmailCode(): Promise<void>;
+    confirm(): Promise<void>;
+    /** Emits the result after the user saved the recovery codes. */
+    finish(): void;
+    private complete;
+    private run;
+    private token;
+    private focusCode;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhTwoFactorEnrollmentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhTwoFactorEnrollmentComponent, "nh-two-factor-enrollment", never, { "enrollment": { "alias": "enrollment"; "required": true; "isSignal": true; }; }, { "completed": "completed"; "expired": "expired"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/**
+ * Shows recovery codes once, with copy and download actions. The user confirms that the
+ * codes were saved before continuing.
+ */
+declare class NhTwoFactorRecoveryCodesComponent {
+    readonly codes: _angular_core.InputSignal<readonly string[]>;
+    /** File name of the downloaded codes. */
+    readonly fileName: _angular_core.InputSignal<string>;
+    readonly acknowledged: _angular_core.OutputEmitterRef<void>;
+    readonly id: string;
+    readonly saved: _angular_core.WritableSignal<boolean>;
+    readonly copied: _angular_core.WritableSignal<boolean>;
+    readonly checked: typeof nhTwoFactorInputChecked;
+    constructor();
+    copy(): Promise<void>;
+    download(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhTwoFactorRecoveryCodesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhTwoFactorRecoveryCodesComponent, "nh-two-factor-recovery-codes", never, { "codes": { "alias": "codes"; "required": true; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; }, { "acknowledged": "acknowledged"; }, never, never, true, never>;
+}
+
+/** A change on the settings page; some need reauthentication before they run. */
+type NhTwoFactorSettingsAction = {
+    kind: 'authenticator';
+} | {
+    kind: 'email';
+} | {
+    kind: 'recovery-codes';
+} | {
+    kind: 'forget-devices';
+} | {
+    kind: 'disable';
+} | {
+    kind: 'add-passkey';
+} | {
+    kind: 'remove-passkey';
+    passkeyId: string;
+};
+/**
+ * Two-factor settings of the signed-in user: authenticator app, e-mail codes, passkeys,
+ * recovery codes, remembered devices and turning two-factor authentication off. Sensitive
+ * changes ask for the password or a code first.
+ */
+declare class NhTwoFactorSettingsComponent implements OnInit {
+    private readonly auth;
+    private readonly injector;
+    private readonly reauthenticationInput;
+    private readonly codeInput;
+    /** Reauthentication of a running e-mail setup, reused when the user requests a new code. */
+    private emailReauthentication?;
+    /** Whether the title is visible. Hosts with their own heading hide it; screen readers keep it. */
+    readonly showTitle: _angular_core.InputSignal<boolean>;
+    /** Emits the reloaded status after every saved change. */
+    readonly changed: _angular_core.OutputEmitterRef<NhTwoFactorStatus>;
+    readonly id: string;
+    readonly passkeySupported: boolean;
+    readonly status: _angular_core.WritableSignal<NhTwoFactorStatus | null>;
+    readonly passkeys: _angular_core.WritableSignal<NhPasskey[]>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly errorKeys: _angular_core.WritableSignal<string[]>;
+    readonly noticeKey: _angular_core.WritableSignal<string | null>;
+    readonly setupPanel: _angular_core.WritableSignal<"authenticator" | "email" | null>;
+    readonly setup: _angular_core.WritableSignal<NhAuthenticatorSetup | null>;
+    readonly emailSent: _angular_core.WritableSignal<NhTwoFactorEmailCodeSent | null>;
+    readonly code: _angular_core.WritableSignal<string>;
+    readonly recoveryCodes: _angular_core.WritableSignal<string[] | null>;
+    readonly pendingAction: _angular_core.WritableSignal<NhTwoFactorSettingsAction | null>;
+    readonly reauthenticationMethod: _angular_core.WritableSignal<string>;
+    readonly reauthenticationSecret: _angular_core.WritableSignal<string>;
+    readonly newPasskeyName: _angular_core.WritableSignal<string>;
+    readonly renamingId: _angular_core.WritableSignal<string | null>;
+    readonly renameValue: _angular_core.WritableSignal<string>;
+    readonly enabled: _angular_core.Signal<boolean>;
+    readonly required: _angular_core.Signal<boolean>;
+    readonly hasAuthenticator: _angular_core.Signal<boolean>;
+    readonly hasEmail: _angular_core.Signal<boolean>;
+    readonly authenticatorAvailable: _angular_core.Signal<boolean>;
+    readonly emailAvailable: _angular_core.Signal<boolean>;
+    readonly passkeysAvailable: _angular_core.Signal<boolean>;
+    readonly recoveryCodesAvailable: _angular_core.Signal<boolean>;
+    readonly reauthenticationMethods: _angular_core.Signal<string[]>;
+    readonly value: typeof nhTwoFactorInputValue;
+    constructor();
+    ngOnInit(): void;
+    load(): Promise<void>;
+    /** Starts a change, asking for reauthentication first when the change needs it. */
+    request(action: NhTwoFactorSettingsAction): void;
+    confirmReauthentication(): Promise<void>;
+    cancelReauthentication(): void;
+    confirmSetup(): Promise<void>;
+    closeSetup(): void;
+    resendEmailCode(): Promise<void>;
+    startRename(passkey: NhPasskey): void;
+    cancelRename(): void;
+    saveRename(passkey: NhPasskey): Promise<void>;
+    private needsReauthentication;
+    private perform;
+    private openSetup;
+    private applyChange;
+    private run;
+    private hasMethod;
+    private isAvailable;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhTwoFactorSettingsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhTwoFactorSettingsComponent, "nh-two-factor-settings", never, { "showTitle": { "alias": "showTitle"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+/**
+ * Signs in with a discoverable passkey, without a username or password. Renders nothing in
+ * browsers without passkey support.
+ */
+declare class NhPasskeyLoginButtonComponent {
+    private readonly auth;
+    /** Whether the button shows failures itself. */
+    readonly showErrors: _angular_core.InputSignal<boolean>;
+    readonly authenticated: _angular_core.OutputEmitterRef<INhAuthorization>;
+    /** The policy asked for more: a second-factor challenge or an enrollment. */
+    readonly pending: _angular_core.OutputEmitterRef<NhAuthenticationStep<INhAuthorization>>;
+    /** Translation keys of a failed sign-in. */
+    readonly failed: _angular_core.OutputEmitterRef<string[]>;
+    readonly id: string;
+    readonly supported: boolean;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly errorKeys: _angular_core.WritableSignal<string[]>;
+    constructor();
+    signIn(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhPasskeyLoginButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhPasskeyLoginButtonComponent, "nh-passkey-login-button", never, { "showErrors": { "alias": "showErrors"; "required": false; "isSignal": true; }; }, { "authenticated": "authenticated"; "pending": "pending"; "failed": "failed"; }, never, never, true, never>;
+}
+
+/** The entry point's own translation bundles, keyed by language. All keys live under `nh-two-factor.`. */
+declare const NH_TWO_FACTOR_TRANSLATIONS: Readonly<Record<'en' | 'nl', TranslationObject>>;
+/**
+ * Merges the bundled texts into `TranslateService` whenever the host loads or replaces a
+ * language. Host loaders never lose these texts, and keys the host defines under
+ * `nh-two-factor.` win over the bundle. Languages without a bundle receive the English texts.
+ */
+declare class NhTwoFactorTranslationMerger {
+    private readonly translate;
+    private readonly destroyRef;
+    private started;
+    start(): void;
+    private ensure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhTwoFactorTranslationMerger, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhTwoFactorTranslationMerger>;
+}
+
+/**
+ * Registers the two-factor texts at startup. The components also register them when they are
+ * first created, so this provider is only needed to translate `nh-two-factor.` failure keys
+ * outside the components, for example on a custom login page.
+ */
+declare function provideNhTwoFactor(): EnvironmentProviders;
+
+export { NH_TWO_FACTOR_TRANSLATIONS, NhPasskeyLoginButtonComponent, NhTwoFactorChallengeComponent, NhTwoFactorEnrollmentComponent, NhTwoFactorRecoveryCodesComponent, NhTwoFactorSettingsComponent, NhTwoFactorTranslationMerger, nhTwoFactorErrorKeys, nhTwoFactorStepEnded, provideNhTwoFactor };
+export type { NhTwoFactorSettingsAction };