valtech-components 2.0.832 → 2.0.834

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

@@ -0,0 +1,252 @@
+import { Component, computed, EventEmitter, inject, Input, Output, signal } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonModal, IonSpinner, IonToolbar, } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { closeOutline } from 'ionicons/icons';
+import { SolidDefaultBlock } from '../../atoms/button/factory';
+import { ComponentStates, InputType } from '../../types';
+import { FormComponent } from '../form/form.component';
+import { AuthService } from '../../../services/auth';
+import { ConfirmationDialogService } from '../../../services/confirmation-dialog/confirmation-dialog.service';
+import { I18nService, InputI18nHelper } from '../../../services/i18n';
+import { ToastService } from '../../../services/toast.service';
+import * as i0 from "@angular/core";
+/**
+ * `val-change-password-modal` — modal de gestión de contraseña para un usuario
+ * autenticado. Análogo al modal de "recuperar contraseña" del `val-login`.
+ *
+ * Es dual-mode: al abrirse consulta `AuthService.checkHasPassword()` y se adapta:
+ *  - **change** — el user ya tiene contraseña → pide actual + nueva →
+ *    `changePassword()`.
+ *  - **set** — el user es OAuth-only (sin contraseña) → pide solo la nueva,
+ *    pide confirmación explícita (no pierde el acceso social, es aditivo) →
+ *    `setPasswordForOAuthUser()`.
+ *
+ * Self-contained: inyecta `AuthService` y llama el endpoint directo — la app
+ * solo controla `[isOpen]` y reacciona a `(changed)` / `(dismissed)`.
+ *
+ * i18n: usa el namespace compartido `_auth` (mismas claves que `val-login`).
+ *
+ * @example
+ * ```html
+ * <val-change-password-modal
+ *   [isOpen]="isModalOpen()"
+ *   (changed)="isModalOpen.set(false)"
+ *   (dismissed)="isModalOpen.set(false)"
+ * />
+ * ```
+ */
+export class ChangePasswordModalComponent {
+    /**
+     * Controla la visibilidad del modal. Lo decide el componente padre. Cada vez
+     * que pasa de cerrado a abierto se resuelve el modo (change vs set).
+     */
+    set isOpen(value) {
+        const opening = value && !this._isOpen;
+        this._isOpen = value;
+        if (opening) {
+            this.resolveMode();
+        }
+    }
+    get isOpen() {
+        return this._isOpen;
+    }
+    constructor() {
+        this._isOpen = false;
+        /** Emite al cambiar/crear la contraseña con éxito. El padre cierra el modal. */
+        this.changed = new EventEmitter();
+        /** Emite cuando el user cierra el modal (botón X o backdrop). */
+        this.dismissed = new EventEmitter();
+        this.auth = inject(AuthService);
+        this.toast = inject(ToastService);
+        this.i18n = inject(I18nService);
+        this.i18nHelper = inject(InputI18nHelper);
+        this.confirmDialog = inject(ConfirmationDialogService);
+        this._mode = signal('loading');
+        /** Modo actual — `loading` mientras se consulta `checkHasPassword()`. */
+        this.mode = this._mode.asReadonly();
+        this._formState = signal(ComponentStates.ENABLED);
+        this.formProps = computed(() => {
+            if (this._mode() === 'set') {
+                return this.i18nHelper.resolveForm({
+                    nameKey: 'setPasswordTitle',
+                    i18nNamespace: '_auth',
+                    sections: [
+                        {
+                            name: this.t('setPasswordDescription'),
+                            order: 0,
+                            fields: [this.newPasswordField(0)],
+                        },
+                    ],
+                    actions: {
+                        ...SolidDefaultBlock('', 'submit'),
+                        token: 'set-submit',
+                        textKey: 'setPasswordSubmit',
+                    },
+                    state: this._formState(),
+                });
+            }
+            return this.i18nHelper.resolveForm({
+                nameKey: 'changePasswordTitle',
+                i18nNamespace: '_auth',
+                sections: [
+                    {
+                        name: this.t('changePasswordDescription'),
+                        order: 0,
+                        fields: [
+                            {
+                                type: InputType.PASSWORD,
+                                name: 'currentPassword',
+                                token: 'change-current-password',
+                                labelKey: 'currentPassword',
+                                hint: '',
+                                placeholderKey: 'passwordPlaceholder',
+                                errorKeys: {
+                                    required: 'currentPasswordRequired',
+                                },
+                                validators: [Validators.required],
+                                order: 0,
+                                state: ComponentStates.ENABLED,
+                            },
+                            this.newPasswordField(1),
+                        ],
+                    },
+                ],
+                actions: {
+                    ...SolidDefaultBlock('', 'submit'),
+                    token: 'change-submit',
+                    textKey: 'changePasswordSubmit',
+                },
+                state: this._formState(),
+            });
+        });
+        addIcons({ closeOutline });
+    }
+    /** Traduce una clave del namespace `_auth`. */
+    t(key) {
+        return this.i18n.t(key, '_auth');
+    }
+    /** Campo "nueva contraseña" — compartido por ambos modos. */
+    newPasswordField(order) {
+        return {
+            type: InputType.PASSWORD,
+            name: 'newPassword',
+            token: 'change-new-password',
+            labelKey: 'newPassword',
+            hintKey: 'newPasswordHint',
+            placeholderKey: 'passwordPlaceholder',
+            errorKeys: {
+                required: 'passwordRequired',
+                minlength: 'passwordMinLength',
+            },
+            validators: [Validators.required, Validators.minLength(8)],
+            order,
+            state: ComponentStates.ENABLED,
+        };
+    }
+    /** Cierre iniciado por el user (X / backdrop). */
+    close() {
+        this.dismissed.emit();
+    }
+    /** Consulta si el user ya tiene contraseña para elegir el modo del modal. */
+    resolveMode() {
+        this._mode.set('loading');
+        this._formState.set(ComponentStates.ENABLED);
+        this.auth.checkHasPassword().subscribe({
+            next: res => this._mode.set(res.hasPassword ? 'change' : 'set'),
+            // Fallback conservador: ante un fallo, asumir flujo de cambio normal.
+            error: () => this._mode.set('change'),
+        });
+    }
+    async submitHandler(event) {
+        if (this._mode() === 'set') {
+            await this.handleSetPassword(event);
+            return;
+        }
+        this.handleChangePassword(event);
+    }
+    /** Flujo normal: el user tiene contraseña y la cambia. */
+    handleChangePassword(event) {
+        const currentPassword = event.fields['currentPassword'];
+        const newPassword = event.fields['newPassword'];
+        if (!currentPassword || !newPassword) {
+            this.showToast(this.t('completeAllFields'));
+            return;
+        }
+        this._formState.set(ComponentStates.WORKING);
+        this.auth.changePassword(currentPassword, newPassword).subscribe({
+            next: () => {
+                this._formState.set(ComponentStates.ENABLED);
+                this.showToast(this.t('passwordChangedSuccess'));
+                this.changed.emit();
+            },
+            error: err => {
+                this._formState.set(ComponentStates.ENABLED);
+                this.showToast(this.resolveError(err));
+            },
+        });
+    }
+    /**
+     * Flujo OAuth-only: el user no tiene contraseña. Antes de crearla pide
+     * confirmación explícita — es un cambio de cuenta, aunque aditivo (conserva
+     * el acceso social).
+     */
+    async handleSetPassword(event) {
+        const newPassword = event.fields['newPassword'];
+        if (!newPassword) {
+            this.showToast(this.t('completeAllFields'));
+            return;
+        }
+        const result = await this.confirmDialog.confirm({
+            title: this.t('setPasswordConfirmTitle'),
+            message: this.t('setPasswordConfirmMessage'),
+            confirmButton: { text: this.t('setPasswordConfirmOk'), role: 'confirm' },
+            cancelButton: { text: this.t('setPasswordConfirmCancel'), role: 'cancel' },
+        });
+        if (!result.confirmed) {
+            return;
+        }
+        this._formState.set(ComponentStates.WORKING);
+        this.auth.setPasswordForOAuthUser(newPassword).subscribe({
+            next: () => {
+                this._formState.set(ComponentStates.ENABLED);
+                this.showToast(this.t('passwordSetSuccess'));
+                this.changed.emit();
+            },
+            error: err => {
+                this._formState.set(ComponentStates.ENABLED);
+                this.showToast(this.resolveError(err));
+            },
+        });
+    }
+    /** Mapea los códigos de error del backend a mensajes del namespace `_auth`. */
+    resolveError(err) {
+        const code = err?.code;
+        switch (code) {
+            case 'AUTHV2_INVALID_CURRENT_PASSWORD':
+                return this.t('errorCurrentPasswordWrong');
+            case 'AUTHV2_SAME_PASSWORD':
+                return this.t('errorSamePassword');
+            case 'AUTHV2_PASSWORD_ALREADY_SET':
+                return this.t('errorPasswordAlreadySet');
+            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: ChangePasswordModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ChangePasswordModalComponent, isStandalone: true, selector: "val-change-password-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\" (click)=\"close()\">\n            <ion-icon name=\"close-outline\"></ion-icon>\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 (mode() === 'loading') {\n        <div class=\"modal-loading\">\n          <ion-spinner name=\"crescent\"></ion-spinner>\n        </div>\n        } @else {\n        <val-form [props]=\"formProps()\" (onSubmit)=\"submitHandler($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: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { 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"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChangePasswordModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-change-password-modal', standalone: true, imports: [IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonModal, IonSpinner, IonToolbar, FormComponent], 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\" (click)=\"close()\">\n            <ion-icon name=\"close-outline\"></ion-icon>\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 (mode() === 'loading') {\n        <div class=\"modal-loading\">\n          <ion-spinner name=\"crescent\"></ion-spinner>\n        </div>\n        } @else {\n        <val-form [props]=\"formProps()\" (onSubmit)=\"submitHandler($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"] }]
+        }], ctorParameters: () => [], propDecorators: { isOpen: [{
+                type: Input
+            }], changed: [{
+                type: Output
+            }], dismissed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"change-password-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/change-password-modal/change-password-modal.component.ts","../../../../../../../src/lib/components/organisms/change-password-modal/change-password-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  IonIcon,\n  IonModal,\n  IonSpinner,\n  IonToolbar,\n} from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { closeOutline } from 'ionicons/icons';\n\nimport { SolidDefaultBlock } from '../../atoms/button/factory';\nimport { ComponentState, ComponentStates, FormMetadata, FormSubmit, InputType } from '../../types';\nimport { FormComponent } from '../form/form.component';\nimport { AuthService } from '../../../services/auth';\nimport { ConfirmationDialogService } from '../../../services/confirmation-dialog/confirmation-dialog.service';\nimport { I18nService, InputI18nHelper } from '../../../services/i18n';\nimport { ToastService } from '../../../services/toast.service';\n\n/** Modo del modal, resuelto al abrir según si el user ya tiene contraseña. */\ntype PasswordModalMode = 'loading' | 'change' | 'set';\n\n/**\n * `val-change-password-modal` — modal de gestión de contraseña para un usuario\n * autenticado. Análogo al modal de \"recuperar contraseña\" del `val-login`.\n *\n * Es dual-mode: al abrirse consulta `AuthService.checkHasPassword()` y se adapta:\n *  - **change** — el user ya tiene contraseña → pide actual + nueva →\n *    `changePassword()`.\n *  - **set** — el user es OAuth-only (sin contraseña) → pide solo la nueva,\n *    pide confirmación explícita (no pierde el acceso social, es aditivo) →\n *    `setPasswordForOAuthUser()`.\n *\n * Self-contained: inyecta `AuthService` y llama el endpoint directo — la app\n * solo controla `[isOpen]` y reacciona a `(changed)` / `(dismissed)`.\n *\n * i18n: usa el namespace compartido `_auth` (mismas claves que `val-login`).\n *\n * @example\n * ```html\n * <val-change-password-modal\n *   [isOpen]=\"isModalOpen()\"\n *   (changed)=\"isModalOpen.set(false)\"\n *   (dismissed)=\"isModalOpen.set(false)\"\n * />\n * ```\n */\n@Component({\n  selector: 'val-change-password-modal',\n  standalone: true,\n  imports: [IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonModal, IonSpinner, IonToolbar, FormComponent],\n  templateUrl: './change-password-modal.component.html',\n  styleUrls: ['./change-password-modal.component.scss'],\n})\nexport class ChangePasswordModalComponent {\n  private _isOpen = false;\n\n  /**\n   * Controla la visibilidad del modal. Lo decide el componente padre. Cada vez\n   * que pasa de cerrado a abierto se resuelve el modo (change vs set).\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 cambiar/crear la contraseña con éxito. El padre cierra el modal. */\n  @Output() changed = new EventEmitter<void>();\n\n  /** Emite cuando el user cierra el modal (botón X o backdrop). */\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  private confirmDialog = inject(ConfirmationDialogService);\n\n  private readonly _mode = signal<PasswordModalMode>('loading');\n  /** Modo actual — `loading` mientras se consulta `checkHasPassword()`. */\n  readonly mode = this._mode.asReadonly();\n\n  private readonly _formState = signal<ComponentState>(ComponentStates.ENABLED);\n\n  constructor() {\n    addIcons({ closeOutline });\n  }\n\n  /** Traduce una clave del namespace `_auth`. */\n  t(key: string): string {\n    return this.i18n.t(key, '_auth');\n  }\n\n  readonly formProps = computed<FormMetadata>(() => {\n    if (this._mode() === 'set') {\n      return this.i18nHelper.resolveForm({\n        nameKey: 'setPasswordTitle',\n        i18nNamespace: '_auth',\n        sections: [\n          {\n            name: this.t('setPasswordDescription'),\n            order: 0,\n            fields: [this.newPasswordField(0)],\n          },\n        ],\n        actions: {\n          ...SolidDefaultBlock('', 'submit'),\n          token: 'set-submit',\n          textKey: 'setPasswordSubmit',\n        },\n        state: this._formState(),\n      });\n    }\n\n    return this.i18nHelper.resolveForm({\n      nameKey: 'changePasswordTitle',\n      i18nNamespace: '_auth',\n      sections: [\n        {\n          name: this.t('changePasswordDescription'),\n          order: 0,\n          fields: [\n            {\n              type: InputType.PASSWORD,\n              name: 'currentPassword',\n              token: 'change-current-password',\n              labelKey: 'currentPassword',\n              hint: '',\n              placeholderKey: 'passwordPlaceholder',\n              errorKeys: {\n                required: 'currentPasswordRequired',\n              },\n              validators: [Validators.required],\n              order: 0,\n              state: ComponentStates.ENABLED,\n            },\n            this.newPasswordField(1),\n          ],\n        },\n      ],\n      actions: {\n        ...SolidDefaultBlock('', 'submit'),\n        token: 'change-submit',\n        textKey: 'changePasswordSubmit',\n      },\n      state: this._formState(),\n    });\n  });\n\n  /** Campo \"nueva contraseña\" — compartido por ambos modos. */\n  private newPasswordField(order: number) {\n    return {\n      type: InputType.PASSWORD,\n      name: 'newPassword',\n      token: 'change-new-password',\n      labelKey: 'newPassword',\n      hintKey: 'newPasswordHint',\n      placeholderKey: 'passwordPlaceholder',\n      errorKeys: {\n        required: 'passwordRequired',\n        minlength: 'passwordMinLength',\n      },\n      validators: [Validators.required, Validators.minLength(8)],\n      order,\n      state: ComponentStates.ENABLED,\n    };\n  }\n\n  /** Cierre iniciado por el user (X / backdrop). */\n  close(): void {\n    this.dismissed.emit();\n  }\n\n  /** Consulta si el user ya tiene contraseña para elegir el modo del modal. */\n  private resolveMode(): void {\n    this._mode.set('loading');\n    this._formState.set(ComponentStates.ENABLED);\n    this.auth.checkHasPassword().subscribe({\n      next: res => this._mode.set(res.hasPassword ? 'change' : 'set'),\n      // Fallback conservador: ante un fallo, asumir flujo de cambio normal.\n      error: () => this._mode.set('change'),\n    });\n  }\n\n  async submitHandler(event: FormSubmit): Promise<void> {\n    if (this._mode() === 'set') {\n      await this.handleSetPassword(event);\n      return;\n    }\n    this.handleChangePassword(event);\n  }\n\n  /** Flujo normal: el user tiene contraseña y la cambia. */\n  private handleChangePassword(event: FormSubmit): void {\n    const currentPassword = event.fields['currentPassword'];\n    const newPassword = event.fields['newPassword'];\n\n    if (!currentPassword || !newPassword) {\n      this.showToast(this.t('completeAllFields'));\n      return;\n    }\n\n    this._formState.set(ComponentStates.WORKING);\n\n    this.auth.changePassword(currentPassword, newPassword).subscribe({\n      next: () => {\n        this._formState.set(ComponentStates.ENABLED);\n        this.showToast(this.t('passwordChangedSuccess'));\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  /**\n   * Flujo OAuth-only: el user no tiene contraseña. Antes de crearla pide\n   * confirmación explícita — es un cambio de cuenta, aunque aditivo (conserva\n   * el acceso social).\n   */\n  private async handleSetPassword(event: FormSubmit): Promise<void> {\n    const newPassword = event.fields['newPassword'];\n\n    if (!newPassword) {\n      this.showToast(this.t('completeAllFields'));\n      return;\n    }\n\n    const result = await this.confirmDialog.confirm({\n      title: this.t('setPasswordConfirmTitle'),\n      message: this.t('setPasswordConfirmMessage'),\n      confirmButton: { text: this.t('setPasswordConfirmOk'), role: 'confirm' },\n      cancelButton: { text: this.t('setPasswordConfirmCancel'), role: 'cancel' },\n    });\n    if (!result.confirmed) {\n      return;\n    }\n\n    this._formState.set(ComponentStates.WORKING);\n\n    this.auth.setPasswordForOAuthUser(newPassword).subscribe({\n      next: () => {\n        this._formState.set(ComponentStates.ENABLED);\n        this.showToast(this.t('passwordSetSuccess'));\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  /** Mapea los códigos de error del backend a mensajes del namespace `_auth`. */\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_SAME_PASSWORD':\n        return this.t('errorSamePassword');\n      case 'AUTHV2_PASSWORD_ALREADY_SET':\n        return this.t('errorPasswordAlreadySet');\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\" (click)=\"close()\">\n            <ion-icon name=\"close-outline\"></ion-icon>\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 (mode() === 'loading') {\n        <div class=\"modal-loading\">\n          <ion-spinner name=\"crescent\"></ion-spinner>\n        </div>\n        } @else {\n        <val-form [props]=\"formProps()\" (onSubmit)=\"submitHandler($event)\" />\n        }\n      </section>\n    </ion-content>\n  </ng-template>\n</ion-modal>\n"]}

package/esm2022/lib/services/auth/interceptor.mjs

@@ -79,7 +79,7 @@ function isPublicEndpoint(request, authPrefix) {
         '/logout',
         '/mfa/verify', // Solo durante login
     ];
-    return publicEndpoints.some((endpoint) => request.url.includes(`${authPrefix}${endpoint}`));
+    return publicEndpoints.some(endpoint => request.url.includes(`${authPrefix}${endpoint}`));
 }
 /**
  * Verifica si la request es a un endpoint que NO debe reintentar refresh en 401.
@@ -88,6 +88,9 @@ function isNoRefreshEndpoint(request, authPrefix) {
     // Endpoints que no deben intentar refresh en 401:
     // - Públicos: signin, signup, refresh, logout
     // - MFA: verify (durante login), confirm (401 = código incorrecto), disable (401 = contraseña incorrecta)
+    // - change-password: 401 = contraseña actual incorrecta, NO token expirado.
+    //   Sin esta exclusión, el retry tras refresh vuelve a dar 401 y el
+    //   catchError de handle401Error dispara logout.
     const noRefreshEndpoints = [
         '/signin',
         '/signup',
@@ -96,8 +99,9 @@ function isNoRefreshEndpoint(request, authPrefix) {
         '/mfa/verify',
         '/mfa/confirm',
         '/mfa/disable',
+        '/change-password',
     ];
-    return noRefreshEndpoints.some((endpoint) => request.url.includes(`${authPrefix}${endpoint}`));
+    return noRefreshEndpoints.some(endpoint => request.url.includes(`${authPrefix}${endpoint}`));
 }
 /**
  * Maneja errores 401 refrescando el token.
@@ -106,10 +110,10 @@ function handle401Error(request, next, authService) {
     if (!isRefreshing) {
         isRefreshing = true;
         refreshTokenSubject.next(null);
-        return authService.refreshAccessToken().pipe(switchMap((response) => {
+        return authService.refreshAccessToken().pipe(switchMap(response => {
             refreshTokenSubject.next(response.accessToken);
             return next(addAuthHeader(request, response.accessToken));
-        }), catchError((error) => {
+        }), catchError(error => {
             authService.logout();
             return throwError(() => error);
         }), finalize(() => {
@@ -117,6 +121,6 @@ function handle401Error(request, next, authService) {
         }));
     }
     // Esperar a que termine el refresco en curso
-    return refreshTokenSubject.pipe(filter((token) => token !== null), take(1), switchMap((token) => next(addAuthHeader(request, token))));
+    return refreshTokenSubject.pipe(filter((token) => token !== null), take(1), switchMap(token => next(addAuthHeader(request, token))));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from '@angular/core';\nimport {\n  HttpInterceptorFn,\n  HttpRequest,\n  HttpHandlerFn,\n  HttpEvent,\n  HttpErrorResponse,\n} from '@angular/common/http';\nimport { Observable, throwError, BehaviorSubject } from 'rxjs';\nimport { catchError, filter, take, switchMap, finalize } from 'rxjs/operators';\nimport { AuthService } from './auth.service';\nimport { VALTECH_AUTH_CONFIG } from './config';\n\n// Control de estado de refresco (singleton a nivel de módulo)\nlet isRefreshing = false;\nconst refreshTokenSubject = new BehaviorSubject<string | null>(null);\n\n/**\n * Interceptor HTTP que:\n * 1. Agrega header Authorization con Bearer token a requests API\n * 2. Maneja errores 401 refrescando el token automáticamente\n * 3. Encola requests durante el refresco para evitar múltiples refresh\n *\n * @example\n * ```typescript\n * // Incluido automáticamente por provideValtechAuth()\n * // Para uso manual:\n * import { provideHttpClient, withInterceptors } from '@angular/common/http';\n * import { authInterceptor } from 'valtech-components';\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     provideHttpClient(withInterceptors([authInterceptor])),\n *   ],\n * });\n * ```\n */\nexport const authInterceptor: HttpInterceptorFn = (\n  request: HttpRequest<unknown>,\n  next: HttpHandlerFn\n): Observable<HttpEvent<unknown>> => {\n  const authService = inject(AuthService);\n  const config = inject(VALTECH_AUTH_CONFIG);\n\n  // Omitir requests que no son a nuestra API\n  if (!isApiRequest(request, config.apiUrl)) {\n    return next(request);\n  }\n\n  // Omitir endpoints públicos que no necesitan token\n  if (isPublicEndpoint(request, config.authPrefix!)) {\n    return next(request);\n  }\n\n  const accessToken = authService.accessToken();\n\n  // Agregar header de autorización si hay token\n  if (accessToken) {\n    request = addAuthHeader(request, accessToken);\n  }\n\n  return next(request).pipe(\n    catchError((error: HttpErrorResponse) => {\n      if (error.status === 401 && !isNoRefreshEndpoint(request, config.authPrefix!)) {\n        return handle401Error(request, next, authService);\n      }\n\n      if (error.status === 403) {\n        console.error(\n          '[ValtechAuth] Permiso denegado:',\n          error.error?.message || 'Acceso prohibido'\n        );\n      }\n\n      return throwError(() => error);\n    })\n  );\n};\n\n/**\n * Agrega header de autorización a la request.\n */\nfunction addAuthHeader(\n  request: HttpRequest<unknown>,\n  token: string\n): HttpRequest<unknown> {\n  return request.clone({\n    setHeaders: {\n      Authorization: `Bearer ${token}`,\n    },\n  });\n}\n\n/**\n * Verifica si la request es a nuestra API.\n */\nfunction isApiRequest(request: HttpRequest<unknown>, apiUrl: string): boolean {\n  return request.url.startsWith(apiUrl) || request.url.includes('/v2/auth');\n}\n\n/**\n * Verifica si la request es a un endpoint público que NO requiere token.\n */\nfunction isPublicEndpoint(\n  request: HttpRequest<unknown>,\n  authPrefix: string\n): boolean {\n  const publicEndpoints = [\n    '/signin',\n    '/signup',\n    '/refresh',\n    '/logout',\n    '/mfa/verify', // Solo durante login\n  ];\n  return publicEndpoints.some((endpoint) =>\n    request.url.includes(`${authPrefix}${endpoint}`)\n  );\n}\n\n/**\n * Verifica si la request es a un endpoint que NO debe reintentar refresh en 401.\n */\nfunction isNoRefreshEndpoint(\n  request: HttpRequest<unknown>,\n  authPrefix: string\n): boolean {\n  // Endpoints que no deben intentar refresh en 401:\n  // - Públicos: signin, signup, refresh, logout\n  // - MFA: verify (durante login), confirm (401 = código incorrecto), disable (401 = contraseña incorrecta)\n  const noRefreshEndpoints = [\n    '/signin',\n    '/signup',\n    '/refresh',\n    '/logout',\n    '/mfa/verify',\n    '/mfa/confirm',\n    '/mfa/disable',\n  ];\n  return noRefreshEndpoints.some((endpoint) =>\n    request.url.includes(`${authPrefix}${endpoint}`)\n  );\n}\n\n/**\n * Maneja errores 401 refrescando el token.\n */\nfunction handle401Error(\n  request: HttpRequest<unknown>,\n  next: HttpHandlerFn,\n  authService: AuthService\n): Observable<HttpEvent<unknown>> {\n  if (!isRefreshing) {\n    isRefreshing = true;\n    refreshTokenSubject.next(null);\n\n    return authService.refreshAccessToken().pipe(\n      switchMap((response) => {\n        refreshTokenSubject.next(response.accessToken);\n        return next(addAuthHeader(request, response.accessToken));\n      }),\n      catchError((error) => {\n        authService.logout();\n        return throwError(() => error);\n      }),\n      finalize(() => {\n        isRefreshing = false;\n      })\n    );\n  }\n\n  // Esperar a que termine el refresco en curso\n  return refreshTokenSubject.pipe(\n    filter((token): token is string => token !== null),\n    take(1),\n    switchMap((token) => next(addAuthHeader(request, token)))\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from '@angular/core';\nimport {\n  HttpInterceptorFn,\n  HttpRequest,\n  HttpHandlerFn,\n  HttpEvent,\n  HttpErrorResponse,\n} from '@angular/common/http';\nimport { Observable, throwError, BehaviorSubject } from 'rxjs';\nimport { catchError, filter, take, switchMap, finalize } from 'rxjs/operators';\nimport { AuthService } from './auth.service';\nimport { VALTECH_AUTH_CONFIG } from './config';\n\n// Control de estado de refresco (singleton a nivel de módulo)\nlet isRefreshing = false;\nconst refreshTokenSubject = new BehaviorSubject<string | null>(null);\n\n/**\n * Interceptor HTTP que:\n * 1. Agrega header Authorization con Bearer token a requests API\n * 2. Maneja errores 401 refrescando el token automáticamente\n * 3. Encola requests durante el refresco para evitar múltiples refresh\n *\n * @example\n * ```typescript\n * // Incluido automáticamente por provideValtechAuth()\n * // Para uso manual:\n * import { provideHttpClient, withInterceptors } from '@angular/common/http';\n * import { authInterceptor } from 'valtech-components';\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     provideHttpClient(withInterceptors([authInterceptor])),\n *   ],\n * });\n * ```\n */\nexport const authInterceptor: HttpInterceptorFn = (\n  request: HttpRequest<unknown>,\n  next: HttpHandlerFn\n): Observable<HttpEvent<unknown>> => {\n  const authService = inject(AuthService);\n  const config = inject(VALTECH_AUTH_CONFIG);\n\n  // Omitir requests que no son a nuestra API\n  if (!isApiRequest(request, config.apiUrl)) {\n    return next(request);\n  }\n\n  // Omitir endpoints públicos que no necesitan token\n  if (isPublicEndpoint(request, config.authPrefix!)) {\n    return next(request);\n  }\n\n  const accessToken = authService.accessToken();\n\n  // Agregar header de autorización si hay token\n  if (accessToken) {\n    request = addAuthHeader(request, accessToken);\n  }\n\n  return next(request).pipe(\n    catchError((error: HttpErrorResponse) => {\n      if (error.status === 401 && !isNoRefreshEndpoint(request, config.authPrefix!)) {\n        return handle401Error(request, next, authService);\n      }\n\n      if (error.status === 403) {\n        console.error(\n          '[ValtechAuth] Permiso denegado:',\n          error.error?.message || 'Acceso prohibido'\n        );\n      }\n\n      return throwError(() => error);\n    })\n  );\n};\n\n/**\n * Agrega header de autorización a la request.\n */\nfunction addAuthHeader(request: HttpRequest<unknown>, token: string): HttpRequest<unknown> {\n  return request.clone({\n    setHeaders: {\n      Authorization: `Bearer ${token}`,\n    },\n  });\n}\n\n/**\n * Verifica si la request es a nuestra API.\n */\nfunction isApiRequest(request: HttpRequest<unknown>, apiUrl: string): boolean {\n  return request.url.startsWith(apiUrl) || request.url.includes('/v2/auth');\n}\n\n/**\n * Verifica si la request es a un endpoint público que NO requiere token.\n */\nfunction isPublicEndpoint(request: HttpRequest<unknown>, authPrefix: string): boolean {\n  const publicEndpoints = [\n    '/signin',\n    '/signup',\n    '/refresh',\n    '/logout',\n    '/mfa/verify', // Solo durante login\n  ];\n  return publicEndpoints.some(endpoint => request.url.includes(`${authPrefix}${endpoint}`));\n}\n\n/**\n * Verifica si la request es a un endpoint que NO debe reintentar refresh en 401.\n */\nfunction isNoRefreshEndpoint(request: HttpRequest<unknown>, authPrefix: string): boolean {\n  // Endpoints que no deben intentar refresh en 401:\n  // - Públicos: signin, signup, refresh, logout\n  // - MFA: verify (durante login), confirm (401 = código incorrecto), disable (401 = contraseña incorrecta)\n  // - change-password: 401 = contraseña actual incorrecta, NO token expirado.\n  //   Sin esta exclusión, el retry tras refresh vuelve a dar 401 y el\n  //   catchError de handle401Error dispara logout.\n  const noRefreshEndpoints = [\n    '/signin',\n    '/signup',\n    '/refresh',\n    '/logout',\n    '/mfa/verify',\n    '/mfa/confirm',\n    '/mfa/disable',\n    '/change-password',\n  ];\n  return noRefreshEndpoints.some(endpoint => request.url.includes(`${authPrefix}${endpoint}`));\n}\n\n/**\n * Maneja errores 401 refrescando el token.\n */\nfunction handle401Error(\n  request: HttpRequest<unknown>,\n  next: HttpHandlerFn,\n  authService: AuthService\n): Observable<HttpEvent<unknown>> {\n  if (!isRefreshing) {\n    isRefreshing = true;\n    refreshTokenSubject.next(null);\n\n    return authService.refreshAccessToken().pipe(\n      switchMap(response => {\n        refreshTokenSubject.next(response.accessToken);\n        return next(addAuthHeader(request, response.accessToken));\n      }),\n      catchError(error => {\n        authService.logout();\n        return throwError(() => error);\n      }),\n      finalize(() => {\n        isRefreshing = false;\n      })\n    );\n  }\n\n  // Esperar a que termine el refresco en curso\n  return refreshTokenSubject.pipe(\n    filter((token): token is string => token !== null),\n    take(1),\n    switchMap(token => next(addAuthHeader(request, token)))\n  );\n}\n"]}