valtech-components 2.0.914 → 2.0.916

package/esm2022/lib/components/organisms/change-email-modal/change-email-modal.component.mjs

@@ -0,0 +1,293 @@
+import { Component, computed, EventEmitter, inject, Input, Output, signal } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { IonButton, IonButtons, IonContent, IonHeader, IonModal, IonSpinner, IonToolbar, } from '@ionic/angular/standalone';
+import { SolidDefaultBlock } from '../../atoms/button/factory';
+import { ComponentStates, InputType } from '../../types';
+import { FormComponent } from '../form/form.component';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TextComponent } from '../../atoms/text/text.component';
+import { AuthService } from '../../../services/auth';
+import { I18nService, InputI18nHelper } from '../../../services/i18n';
+import { ToastService } from '../../../services/toast.service';
+import * as i0 from "@angular/core";
+/**
+ * `val-change-email-modal` — modal de cambio de email en 3 pasos.
+ *
+ * Paso 1: contraseña actual + nuevo email → `initiateEmailChange()`
+ * Paso 2: código enviado al email actual → `confirmEmailChangeStep1()`
+ * Paso 3: código enviado al nuevo email → `confirmEmailChangeStep2()`
+ *
+ * Si el user no tiene contraseña (cuenta OAuth-only), muestra aviso.
+ *
+ * @example
+ * ```html
+ * <val-change-email-modal
+ *   [isOpen]="isEmailModalOpen()"
+ *   (changed)="isEmailModalOpen.set(false)"
+ *   (dismissed)="isEmailModalOpen.set(false)"
+ * />
+ * ```
+ */
+export class ChangeEmailModalComponent {
+    constructor() {
+        this._isOpen = false;
+        /** Emite al completar el cambio de email con éxito. El padre cierra el modal. */
+        this.changed = new EventEmitter();
+        /** Emite cuando el user cierra el modal. */
+        this.dismissed = new EventEmitter();
+        this.auth = inject(AuthService);
+        this.toast = inject(ToastService);
+        this.i18n = inject(I18nService);
+        this.i18nHelper = inject(InputI18nHelper);
+        this._step = signal('loading');
+        this._pendingEmail = signal('');
+        this._formState = signal(ComponentStates.ENABLED);
+        this.noPasswordTitle = computed(() => this.t('changeEmailNoPasswordTitle'));
+        this.noPasswordHint = computed(() => this.t('changeEmailNoPasswordHint'));
+        this.step1Props = computed(() => this.i18nHelper.resolveForm({
+            nameKey: 'changeEmailTitle',
+            i18nNamespace: '_auth',
+            sections: [
+                {
+                    name: this.t('changeEmailStep1Description'),
+                    order: 0,
+                    fields: [
+                        {
+                            type: InputType.PASSWORD,
+                            name: 'currentPassword',
+                            token: 'change-email-password',
+                            labelKey: 'currentPassword',
+                            hint: '',
+                            placeholderKey: 'passwordPlaceholder',
+                            errorKeys: { required: 'currentPasswordRequired' },
+                            validators: [Validators.required],
+                            order: 0,
+                            state: ComponentStates.ENABLED,
+                        },
+                        {
+                            type: InputType.EMAIL,
+                            name: 'newEmail',
+                            token: 'change-email-new',
+                            labelKey: 'changeEmailNewEmail',
+                            hint: '',
+                            placeholderKey: 'emailPlaceholder',
+                            errorKeys: {
+                                required: 'emailRequired',
+                                email: 'changeEmailNewEmailInvalid',
+                            },
+                            validators: [Validators.required, Validators.email],
+                            order: 1,
+                            state: ComponentStates.ENABLED,
+                        },
+                    ],
+                },
+            ],
+            actions: {
+                ...SolidDefaultBlock('', 'submit'),
+                token: 'change-email-initiate',
+                textKey: 'changeEmailInitiate',
+            },
+            state: this._formState(),
+        }));
+        this.step2Props = computed(() => this.i18nHelper.resolveForm({
+            nameKey: 'changeEmailStep2Title',
+            i18nNamespace: '_auth',
+            sections: [
+                {
+                    name: this.t('changeEmailStep2Description'),
+                    order: 0,
+                    fields: [
+                        {
+                            type: InputType.PIN_CODE,
+                            name: 'code',
+                            token: 'change-email-code-current',
+                            labelKey: 'changeEmailCodeCurrent',
+                            hint: '',
+                            placeholderKey: '',
+                            errorKeys: { required: 'mfaCodeInvalid' },
+                            validators: [Validators.required],
+                            order: 0,
+                            state: ComponentStates.ENABLED,
+                            length: 6,
+                            allowNumbersOnly: true,
+                            autoFocus: true,
+                        },
+                    ],
+                },
+            ],
+            actions: {
+                ...SolidDefaultBlock('', 'submit'),
+                token: 'change-email-confirm-1',
+                textKey: 'changeEmailConfirm1',
+            },
+            state: this._formState(),
+        }));
+        this.step3Props = computed(() => {
+            const email = this._pendingEmail();
+            const desc = this.t('changeEmailStep3Description').replace('{email}', email);
+            return this.i18nHelper.resolveForm({
+                nameKey: 'changeEmailStep3Title',
+                i18nNamespace: '_auth',
+                sections: [
+                    {
+                        name: desc,
+                        order: 0,
+                        fields: [
+                            {
+                                type: InputType.PIN_CODE,
+                                name: 'code',
+                                token: 'change-email-code-new',
+                                labelKey: 'changeEmailCodeNew',
+                                hint: '',
+                                placeholderKey: '',
+                                errorKeys: { required: 'mfaCodeInvalid' },
+                                validators: [Validators.required],
+                                order: 0,
+                                state: ComponentStates.ENABLED,
+                                length: 6,
+                                allowNumbersOnly: true,
+                                autoFocus: true,
+                            },
+                        ],
+                    },
+                ],
+                actions: {
+                    ...SolidDefaultBlock('', 'submit'),
+                    token: 'change-email-confirm-2',
+                    textKey: 'changeEmailConfirm2',
+                },
+                state: this._formState(),
+            });
+        });
+    }
+    set isOpen(value) {
+        const opening = value && !this._isOpen;
+        this._isOpen = value;
+        if (opening) {
+            this.resolveMode();
+        }
+    }
+    get isOpen() {
+        return this._isOpen;
+    }
+    t(key) {
+        return this.i18n.t(key, '_auth');
+    }
+    close() {
+        this.dismissed.emit();
+    }
+    resolveMode() {
+        this._step.set('loading');
+        this._formState.set(ComponentStates.ENABLED);
+        this._pendingEmail.set('');
+        this.auth.checkHasPassword().subscribe({
+            next: res => this._step.set(res.hasPassword ? 'step1' : 'no-password'),
+            error: () => this._step.set('step1'),
+        });
+    }
+    handleStep1(event) {
+        const currentPassword = event.fields['currentPassword'];
+        const newEmail = event.fields['newEmail'];
+        if (!currentPassword || !newEmail) {
+            this.showToast(this.t('completeAllFields'));
+            return;
+        }
+        this._formState.set(ComponentStates.WORKING);
+        this.auth.initiateEmailChange(currentPassword, newEmail).subscribe({
+            next: res => {
+                this._formState.set(ComponentStates.ENABLED);
+                this._pendingEmail.set(res.pendingEmail);
+                this._step.set('step2');
+            },
+            error: err => {
+                this._formState.set(ComponentStates.ENABLED);
+                this.showToast(this.resolveError(err));
+            },
+        });
+    }
+    handleStep2(event) {
+        const code = event.fields['code'];
+        if (!code) {
+            this.showToast(this.t('mfaCodeInvalid'));
+            return;
+        }
+        this._formState.set(ComponentStates.WORKING);
+        this.auth.confirmEmailChangeStep1(code).subscribe({
+            next: () => {
+                this._formState.set(ComponentStates.ENABLED);
+                this._step.set('step3');
+            },
+            error: err => {
+                this._formState.set(ComponentStates.ENABLED);
+                this.showToast(this.resolveError(err));
+            },
+        });
+    }
+    handleStep3(event) {
+        const code = event.fields['code'];
+        if (!code) {
+            this.showToast(this.t('mfaCodeInvalid'));
+            return;
+        }
+        this._formState.set(ComponentStates.WORKING);
+        this.auth.confirmEmailChangeStep2(code).subscribe({
+            next: () => {
+                this._formState.set(ComponentStates.ENABLED);
+                this.showToast(this.t('changeEmailSuccess'));
+                this.changed.emit();
+            },
+            error: err => {
+                this._formState.set(ComponentStates.ENABLED);
+                this.showToast(this.resolveError(err));
+            },
+        });
+    }
+    resolveError(err) {
+        const code = err?.code;
+        switch (code) {
+            case 'AUTHV2_INVALID_CURRENT_PASSWORD':
+                return this.t('errorCurrentPasswordWrong');
+            case 'AUTHV2_EMAIL_SAME_AS_CURRENT':
+                return this.t('errorEmailSameAsCurrent');
+            case 'AUTHV2_EMAIL_EXISTS':
+                return this.t('errorEmailAlreadyInUse');
+            case 'AUTHV2_EMAIL_CHANGE_PENDING_EXPIRED':
+                return this.t('errorEmailChangePendingExpired');
+            case 'AUTHV2_INVALID_CODE':
+                return this.t('errorInvalidCode');
+            case 'AUTHV2_EXPIRED_CODE':
+                return this.t('errorExpiredCode');
+            case 'AUTHV2_TOO_MANY_ATTEMPTS':
+                return this.t('errorTooManyAttempts');
+            default:
+                return this.t('errorGeneric');
+        }
+    }
+    showToast(message) {
+        this.toast.show({ message, duration: 3500 });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChangeEmailModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ChangeEmailModalComponent, isStandalone: true, selector: "val-change-email-modal", inputs: { isOpen: "isOpen" }, outputs: { changed: "changed", dismissed: "dismissed" }, ngImport: i0, template: "<ion-modal [isOpen]=\"isOpen\" (didDismiss)=\"close()\">\n  <ng-template>\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"close()\">\n            <strong>{{ t('close') }}</strong>\n          </ion-button>\n        </ion-buttons>\n      </ion-toolbar>\n    </ion-header>\n    <ion-content class=\"ion-padding\">\n      <section class=\"modal-form-section\">\n        @if (_step() === 'loading') {\n        <div class=\"modal-loading\">\n          <ion-spinner name=\"crescent\"></ion-spinner>\n        </div>\n        } @else if (_step() === 'no-password') {\n        <val-display [props]=\"{ content: noPasswordTitle(), size: 'small', color: 'dark' }\" />\n        <val-text [props]=\"{ content: noPasswordHint(), size: 'medium', color: 'medium', bold: false }\" />\n        } @else if (_step() === 'step1') {\n        <val-form [props]=\"step1Props()\" (onSubmit)=\"handleStep1($event)\" />\n        } @else if (_step() === 'step2') {\n        <val-form [props]=\"step2Props()\" (onSubmit)=\"handleStep2($event)\" />\n        } @else if (_step() === 'step3') {\n        <val-form [props]=\"step3Props()\" (onSubmit)=\"handleStep3($event)\" />\n        }\n      </section>\n    </ion-content>\n  </ng-template>\n</ion-modal>\n", styles: [".modal-form-section{display:flex;flex-direction:column;gap:16px;max-width:420px;margin:0 auto;padding-top:8px}.modal-loading{display:flex;justify-content:center;padding:40px 0}\n"], dependencies: [{ kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: IonModal, selector: "ion-modal" }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: FormComponent, selector: "val-form", inputs: ["props"], outputs: ["onSubmit", "onInvalid", "onSelectChange"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TextComponent, selector: "val-text", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChangeEmailModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-change-email-modal', standalone: true, imports: [
+                        IonButton,
+                        IonButtons,
+                        IonContent,
+                        IonHeader,
+                        IonModal,
+                        IonSpinner,
+                        IonToolbar,
+                        FormComponent,
+                        DisplayComponent,
+                        TextComponent,
+                    ], template: "<ion-modal [isOpen]=\"isOpen\" (didDismiss)=\"close()\">\n  <ng-template>\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"close()\">\n            <strong>{{ t('close') }}</strong>\n          </ion-button>\n        </ion-buttons>\n      </ion-toolbar>\n    </ion-header>\n    <ion-content class=\"ion-padding\">\n      <section class=\"modal-form-section\">\n        @if (_step() === 'loading') {\n        <div class=\"modal-loading\">\n          <ion-spinner name=\"crescent\"></ion-spinner>\n        </div>\n        } @else if (_step() === 'no-password') {\n        <val-display [props]=\"{ content: noPasswordTitle(), size: 'small', color: 'dark' }\" />\n        <val-text [props]=\"{ content: noPasswordHint(), size: 'medium', color: 'medium', bold: false }\" />\n        } @else if (_step() === 'step1') {\n        <val-form [props]=\"step1Props()\" (onSubmit)=\"handleStep1($event)\" />\n        } @else if (_step() === 'step2') {\n        <val-form [props]=\"step2Props()\" (onSubmit)=\"handleStep2($event)\" />\n        } @else if (_step() === 'step3') {\n        <val-form [props]=\"step3Props()\" (onSubmit)=\"handleStep3($event)\" />\n        }\n      </section>\n    </ion-content>\n  </ng-template>\n</ion-modal>\n", styles: [".modal-form-section{display:flex;flex-direction:column;gap:16px;max-width:420px;margin:0 auto;padding-top:8px}.modal-loading{display:flex;justify-content:center;padding:40px 0}\n"] }]
+        }], propDecorators: { isOpen: [{
+                type: Input
+            }], changed: [{
+                type: Output
+            }], dismissed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"change-email-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/change-email-modal/change-email-modal.component.ts","../../../../../../../src/lib/components/organisms/change-email-modal/change-email-modal.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, EventEmitter, inject, Input, Output, signal } from '@angular/core';\nimport { Validators } from '@angular/forms';\nimport {\n  IonButton,\n  IonButtons,\n  IonContent,\n  IonHeader,\n  IonModal,\n  IonSpinner,\n  IonToolbar,\n} from '@ionic/angular/standalone';\n\nimport { SolidDefaultBlock } from '../../atoms/button/factory';\nimport { ComponentState, ComponentStates, FormMetadata, FormSubmit, InputType } from '../../types';\nimport { FormComponent } from '../form/form.component';\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TextComponent } from '../../atoms/text/text.component';\nimport { AuthService } from '../../../services/auth';\nimport { I18nService, InputI18nHelper } from '../../../services/i18n';\nimport { ToastService } from '../../../services/toast.service';\n\ntype EmailModalStep = 'loading' | 'no-password' | 'step1' | 'step2' | 'step3';\n\n/**\n * `val-change-email-modal` — modal de cambio de email en 3 pasos.\n *\n * Paso 1: contraseña actual + nuevo email → `initiateEmailChange()`\n * Paso 2: código enviado al email actual → `confirmEmailChangeStep1()`\n * Paso 3: código enviado al nuevo email → `confirmEmailChangeStep2()`\n *\n * Si el user no tiene contraseña (cuenta OAuth-only), muestra aviso.\n *\n * @example\n * ```html\n * <val-change-email-modal\n *   [isOpen]=\"isEmailModalOpen()\"\n *   (changed)=\"isEmailModalOpen.set(false)\"\n *   (dismissed)=\"isEmailModalOpen.set(false)\"\n * />\n * ```\n */\n@Component({\n  selector: 'val-change-email-modal',\n  standalone: true,\n  imports: [\n    IonButton,\n    IonButtons,\n    IonContent,\n    IonHeader,\n    IonModal,\n    IonSpinner,\n    IonToolbar,\n    FormComponent,\n    DisplayComponent,\n    TextComponent,\n  ],\n  templateUrl: './change-email-modal.component.html',\n  styleUrls: ['./change-email-modal.component.scss'],\n})\nexport class ChangeEmailModalComponent {\n  private _isOpen = false;\n\n  @Input()\n  set isOpen(value: boolean) {\n    const opening = value && !this._isOpen;\n    this._isOpen = value;\n    if (opening) {\n      this.resolveMode();\n    }\n  }\n  get isOpen(): boolean {\n    return this._isOpen;\n  }\n\n  /** Emite al completar el cambio de email con éxito. El padre cierra el modal. */\n  @Output() changed = new EventEmitter<void>();\n\n  /** Emite cuando el user cierra el modal. */\n  @Output() dismissed = new EventEmitter<void>();\n\n  private auth = inject(AuthService);\n  private toast = inject(ToastService);\n  private i18n = inject(I18nService);\n  private i18nHelper = inject(InputI18nHelper);\n\n  readonly _step = signal<EmailModalStep>('loading');\n  readonly _pendingEmail = signal('');\n  private readonly _formState = signal<ComponentState>(ComponentStates.ENABLED);\n\n  t(key: string): string {\n    return this.i18n.t(key, '_auth');\n  }\n\n  readonly noPasswordTitle = computed(() => this.t('changeEmailNoPasswordTitle'));\n  readonly noPasswordHint = computed(() => this.t('changeEmailNoPasswordHint'));\n\n  readonly step1Props = computed<FormMetadata>(() =>\n    this.i18nHelper.resolveForm({\n      nameKey: 'changeEmailTitle',\n      i18nNamespace: '_auth',\n      sections: [\n        {\n          name: this.t('changeEmailStep1Description'),\n          order: 0,\n          fields: [\n            {\n              type: InputType.PASSWORD,\n              name: 'currentPassword',\n              token: 'change-email-password',\n              labelKey: 'currentPassword',\n              hint: '',\n              placeholderKey: 'passwordPlaceholder',\n              errorKeys: { required: 'currentPasswordRequired' },\n              validators: [Validators.required],\n              order: 0,\n              state: ComponentStates.ENABLED,\n            },\n            {\n              type: InputType.EMAIL,\n              name: 'newEmail',\n              token: 'change-email-new',\n              labelKey: 'changeEmailNewEmail',\n              hint: '',\n              placeholderKey: 'emailPlaceholder',\n              errorKeys: {\n                required: 'emailRequired',\n                email: 'changeEmailNewEmailInvalid',\n              },\n              validators: [Validators.required, Validators.email],\n              order: 1,\n              state: ComponentStates.ENABLED,\n            },\n          ],\n        },\n      ],\n      actions: {\n        ...SolidDefaultBlock('', 'submit'),\n        token: 'change-email-initiate',\n        textKey: 'changeEmailInitiate',\n      },\n      state: this._formState(),\n    })\n  );\n\n  readonly step2Props = computed<FormMetadata>(() =>\n    this.i18nHelper.resolveForm({\n      nameKey: 'changeEmailStep2Title',\n      i18nNamespace: '_auth',\n      sections: [\n        {\n          name: this.t('changeEmailStep2Description'),\n          order: 0,\n          fields: [\n            {\n              type: InputType.PIN_CODE,\n              name: 'code',\n              token: 'change-email-code-current',\n              labelKey: 'changeEmailCodeCurrent',\n              hint: '',\n              placeholderKey: '',\n              errorKeys: { required: 'mfaCodeInvalid' },\n              validators: [Validators.required],\n              order: 0,\n              state: ComponentStates.ENABLED,\n              length: 6,\n              allowNumbersOnly: true,\n              autoFocus: true,\n            },\n          ],\n        },\n      ],\n      actions: {\n        ...SolidDefaultBlock('', 'submit'),\n        token: 'change-email-confirm-1',\n        textKey: 'changeEmailConfirm1',\n      },\n      state: this._formState(),\n    })\n  );\n\n  readonly step3Props = computed<FormMetadata>(() => {\n    const email = this._pendingEmail();\n    const desc = this.t('changeEmailStep3Description').replace('{email}', email);\n    return this.i18nHelper.resolveForm({\n      nameKey: 'changeEmailStep3Title',\n      i18nNamespace: '_auth',\n      sections: [\n        {\n          name: desc,\n          order: 0,\n          fields: [\n            {\n              type: InputType.PIN_CODE,\n              name: 'code',\n              token: 'change-email-code-new',\n              labelKey: 'changeEmailCodeNew',\n              hint: '',\n              placeholderKey: '',\n              errorKeys: { required: 'mfaCodeInvalid' },\n              validators: [Validators.required],\n              order: 0,\n              state: ComponentStates.ENABLED,\n              length: 6,\n              allowNumbersOnly: true,\n              autoFocus: true,\n            },\n          ],\n        },\n      ],\n      actions: {\n        ...SolidDefaultBlock('', 'submit'),\n        token: 'change-email-confirm-2',\n        textKey: 'changeEmailConfirm2',\n      },\n      state: this._formState(),\n    });\n  });\n\n  close(): void {\n    this.dismissed.emit();\n  }\n\n  private resolveMode(): void {\n    this._step.set('loading');\n    this._formState.set(ComponentStates.ENABLED);\n    this._pendingEmail.set('');\n    this.auth.checkHasPassword().subscribe({\n      next: res => this._step.set(res.hasPassword ? 'step1' : 'no-password'),\n      error: () => this._step.set('step1'),\n    });\n  }\n\n  handleStep1(event: FormSubmit): void {\n    const currentPassword = event.fields['currentPassword'];\n    const newEmail = event.fields['newEmail'];\n    if (!currentPassword || !newEmail) {\n      this.showToast(this.t('completeAllFields'));\n      return;\n    }\n    this._formState.set(ComponentStates.WORKING);\n    this.auth.initiateEmailChange(currentPassword, newEmail).subscribe({\n      next: res => {\n        this._formState.set(ComponentStates.ENABLED);\n        this._pendingEmail.set(res.pendingEmail);\n        this._step.set('step2');\n      },\n      error: err => {\n        this._formState.set(ComponentStates.ENABLED);\n        this.showToast(this.resolveError(err));\n      },\n    });\n  }\n\n  handleStep2(event: FormSubmit): void {\n    const code = event.fields['code'];\n    if (!code) {\n      this.showToast(this.t('mfaCodeInvalid'));\n      return;\n    }\n    this._formState.set(ComponentStates.WORKING);\n    this.auth.confirmEmailChangeStep1(code).subscribe({\n      next: () => {\n        this._formState.set(ComponentStates.ENABLED);\n        this._step.set('step3');\n      },\n      error: err => {\n        this._formState.set(ComponentStates.ENABLED);\n        this.showToast(this.resolveError(err));\n      },\n    });\n  }\n\n  handleStep3(event: FormSubmit): void {\n    const code = event.fields['code'];\n    if (!code) {\n      this.showToast(this.t('mfaCodeInvalid'));\n      return;\n    }\n    this._formState.set(ComponentStates.WORKING);\n    this.auth.confirmEmailChangeStep2(code).subscribe({\n      next: () => {\n        this._formState.set(ComponentStates.ENABLED);\n        this.showToast(this.t('changeEmailSuccess'));\n        this.changed.emit();\n      },\n      error: err => {\n        this._formState.set(ComponentStates.ENABLED);\n        this.showToast(this.resolveError(err));\n      },\n    });\n  }\n\n  private resolveError(err: unknown): string {\n    const code = (err as { code?: string })?.code;\n    switch (code) {\n      case 'AUTHV2_INVALID_CURRENT_PASSWORD':\n        return this.t('errorCurrentPasswordWrong');\n      case 'AUTHV2_EMAIL_SAME_AS_CURRENT':\n        return this.t('errorEmailSameAsCurrent');\n      case 'AUTHV2_EMAIL_EXISTS':\n        return this.t('errorEmailAlreadyInUse');\n      case 'AUTHV2_EMAIL_CHANGE_PENDING_EXPIRED':\n        return this.t('errorEmailChangePendingExpired');\n      case 'AUTHV2_INVALID_CODE':\n        return this.t('errorInvalidCode');\n      case 'AUTHV2_EXPIRED_CODE':\n        return this.t('errorExpiredCode');\n      case 'AUTHV2_TOO_MANY_ATTEMPTS':\n        return this.t('errorTooManyAttempts');\n      default:\n        return this.t('errorGeneric');\n    }\n  }\n\n  private showToast(message: string): void {\n    this.toast.show({ message, duration: 3500 });\n  }\n}\n","<ion-modal [isOpen]=\"isOpen\" (didDismiss)=\"close()\">\n  <ng-template>\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"close()\">\n            <strong>{{ t('close') }}</strong>\n          </ion-button>\n        </ion-buttons>\n      </ion-toolbar>\n    </ion-header>\n    <ion-content class=\"ion-padding\">\n      <section class=\"modal-form-section\">\n        @if (_step() === 'loading') {\n        <div class=\"modal-loading\">\n          <ion-spinner name=\"crescent\"></ion-spinner>\n        </div>\n        } @else if (_step() === 'no-password') {\n        <val-display [props]=\"{ content: noPasswordTitle(), size: 'small', color: 'dark' }\" />\n        <val-text [props]=\"{ content: noPasswordHint(), size: 'medium', color: 'medium', bold: false }\" />\n        } @else if (_step() === 'step1') {\n        <val-form [props]=\"step1Props()\" (onSubmit)=\"handleStep1($event)\" />\n        } @else if (_step() === 'step2') {\n        <val-form [props]=\"step2Props()\" (onSubmit)=\"handleStep2($event)\" />\n        } @else if (_step() === 'step3') {\n        <val-form [props]=\"step3Props()\" (onSubmit)=\"handleStep3($event)\" />\n        }\n      </section>\n    </ion-content>\n  </ng-template>\n</ion-modal>\n"]}