valtech-components 2.0.691 → 2.0.693

package/esm2022/lib/services/auth/sync.service.mjs

@@ -0,0 +1,149 @@
+import { Inject, Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { VALTECH_AUTH_CONFIG } from './config';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para sincronización de estado de autenticación entre pestañas.
+ * Usa BroadcastChannel API con fallback a storage events.
+ */
+export class AuthSyncService {
+    constructor(config) {
+        this.config = config;
+        this.channel = null;
+        this.eventSubject = new Subject();
+        this.storageListener = null;
+        /** Observable de eventos de sincronización */
+        this.onEvent$ = this.eventSubject.asObservable();
+        const prefix = this.config.storagePrefix || 'valtech_auth_';
+        this.channelName = `${prefix}sync_channel`;
+    }
+    /**
+     * Inicia la sincronización entre pestañas.
+     */
+    start() {
+        if (!this.config.enableTabSync) {
+            return;
+        }
+        // Intentar usar BroadcastChannel API (mejor rendimiento)
+        if (typeof BroadcastChannel !== 'undefined') {
+            this.initBroadcastChannel();
+        }
+        else {
+            // Fallback a storage events
+            this.initStorageEvents();
+        }
+    }
+    /**
+     * Detiene la sincronización.
+     */
+    stop() {
+        if (this.channel) {
+            this.channel.close();
+            this.channel = null;
+        }
+        if (this.storageListener) {
+            window.removeEventListener('storage', this.storageListener);
+            this.storageListener = null;
+        }
+    }
+    /**
+     * Envía un evento a otras pestañas.
+     */
+    broadcast(event) {
+        if (!this.config.enableTabSync) {
+            return;
+        }
+        const fullEvent = {
+            ...event,
+            timestamp: Date.now(),
+        };
+        if (this.channel) {
+            this.channel.postMessage(fullEvent);
+        }
+        else {
+            // Fallback: usar localStorage para notificar
+            this.broadcastViaStorage(fullEvent);
+        }
+    }
+    ngOnDestroy() {
+        this.stop();
+        this.eventSubject.complete();
+    }
+    /**
+     * Inicializa BroadcastChannel API.
+     */
+    initBroadcastChannel() {
+        try {
+            this.channel = new BroadcastChannel(this.channelName);
+            this.channel.onmessage = (event) => {
+                this.handleEvent(event.data);
+            };
+            this.channel.onmessageerror = () => {
+                console.warn('[ValtechAuth] Error en BroadcastChannel, usando fallback');
+                this.channel?.close();
+                this.channel = null;
+                this.initStorageEvents();
+            };
+        }
+        catch {
+            // BroadcastChannel no disponible, usar fallback
+            this.initStorageEvents();
+        }
+    }
+    /**
+     * Inicializa fallback con storage events.
+     */
+    initStorageEvents() {
+        const storageKey = `${this.config.storagePrefix}sync_event`;
+        this.storageListener = (event) => {
+            if (event.key === storageKey && event.newValue) {
+                try {
+                    const syncEvent = JSON.parse(event.newValue);
+                    this.handleEvent(syncEvent);
+                }
+                catch {
+                    // Ignorar eventos mal formados
+                }
+            }
+        };
+        window.addEventListener('storage', this.storageListener);
+    }
+    /**
+     * Envía evento via localStorage (fallback).
+     */
+    broadcastViaStorage(event) {
+        const storageKey = `${this.config.storagePrefix}sync_event`;
+        try {
+            // Escribir y luego limpiar para permitir múltiples eventos del mismo tipo
+            localStorage.setItem(storageKey, JSON.stringify(event));
+            // Usar setTimeout para permitir que otras pestañas lean el valor
+            setTimeout(() => {
+                localStorage.removeItem(storageKey);
+            }, 100);
+        }
+        catch {
+            console.warn('[ValtechAuth] Error enviando evento via storage');
+        }
+    }
+    /**
+     * Maneja un evento recibido.
+     */
+    handleEvent(event) {
+        // Verificar que el evento no sea muy antiguo (más de 5 segundos)
+        const age = Date.now() - event.timestamp;
+        if (age > 5000) {
+            return;
+        }
+        this.eventSubject.next(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthSyncService, deps: [{ token: VALTECH_AUTH_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthSyncService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthSyncService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/sync.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, OnDestroy } from '@angular/core';\nimport { Subject, Observable } from 'rxjs';\nimport { VALTECH_AUTH_CONFIG } from './config';\nimport { AuthSyncEvent, AuthSyncEventType, ValtechAuthConfig } from './types';\n\n/**\n * Servicio para sincronización de estado de autenticación entre pestañas.\n * Usa BroadcastChannel API con fallback a storage events.\n */\n@Injectable({ providedIn: 'root' })\nexport class AuthSyncService implements OnDestroy {\n  private channel: BroadcastChannel | null = null;\n  private channelName: string;\n  private eventSubject = new Subject<AuthSyncEvent>();\n  private storageListener: ((event: StorageEvent) => void) | null = null;\n\n  /** Observable de eventos de sincronización */\n  readonly onEvent$: Observable<AuthSyncEvent> = this.eventSubject.asObservable();\n\n  constructor(\n    @Inject(VALTECH_AUTH_CONFIG) private config: ValtechAuthConfig\n  ) {\n    const prefix = this.config.storagePrefix || 'valtech_auth_';\n    this.channelName = `${prefix}sync_channel`;\n  }\n\n  /**\n   * Inicia la sincronización entre pestañas.\n   */\n  start(): void {\n    if (!this.config.enableTabSync) {\n      return;\n    }\n\n    // Intentar usar BroadcastChannel API (mejor rendimiento)\n    if (typeof BroadcastChannel !== 'undefined') {\n      this.initBroadcastChannel();\n    } else {\n      // Fallback a storage events\n      this.initStorageEvents();\n    }\n  }\n\n  /**\n   * Detiene la sincronización.\n   */\n  stop(): void {\n    if (this.channel) {\n      this.channel.close();\n      this.channel = null;\n    }\n\n    if (this.storageListener) {\n      window.removeEventListener('storage', this.storageListener);\n      this.storageListener = null;\n    }\n  }\n\n  /**\n   * Envía un evento a otras pestañas.\n   */\n  broadcast(event: Omit<AuthSyncEvent, 'timestamp'>): void {\n    if (!this.config.enableTabSync) {\n      return;\n    }\n\n    const fullEvent: AuthSyncEvent = {\n      ...event,\n      timestamp: Date.now(),\n    };\n\n    if (this.channel) {\n      this.channel.postMessage(fullEvent);\n    } else {\n      // Fallback: usar localStorage para notificar\n      this.broadcastViaStorage(fullEvent);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.stop();\n    this.eventSubject.complete();\n  }\n\n  /**\n   * Inicializa BroadcastChannel API.\n   */\n  private initBroadcastChannel(): void {\n    try {\n      this.channel = new BroadcastChannel(this.channelName);\n\n      this.channel.onmessage = (event: MessageEvent<AuthSyncEvent>) => {\n        this.handleEvent(event.data);\n      };\n\n      this.channel.onmessageerror = () => {\n        console.warn('[ValtechAuth] Error en BroadcastChannel, usando fallback');\n        this.channel?.close();\n        this.channel = null;\n        this.initStorageEvents();\n      };\n    } catch {\n      // BroadcastChannel no disponible, usar fallback\n      this.initStorageEvents();\n    }\n  }\n\n  /**\n   * Inicializa fallback con storage events.\n   */\n  private initStorageEvents(): void {\n    const storageKey = `${this.config.storagePrefix}sync_event`;\n\n    this.storageListener = (event: StorageEvent) => {\n      if (event.key === storageKey && event.newValue) {\n        try {\n          const syncEvent: AuthSyncEvent = JSON.parse(event.newValue);\n          this.handleEvent(syncEvent);\n        } catch {\n          // Ignorar eventos mal formados\n        }\n      }\n    };\n\n    window.addEventListener('storage', this.storageListener);\n  }\n\n  /**\n   * Envía evento via localStorage (fallback).\n   */\n  private broadcastViaStorage(event: AuthSyncEvent): void {\n    const storageKey = `${this.config.storagePrefix}sync_event`;\n\n    try {\n      // Escribir y luego limpiar para permitir múltiples eventos del mismo tipo\n      localStorage.setItem(storageKey, JSON.stringify(event));\n      // Usar setTimeout para permitir que otras pestañas lean el valor\n      setTimeout(() => {\n        localStorage.removeItem(storageKey);\n      }, 100);\n    } catch {\n      console.warn('[ValtechAuth] Error enviando evento via storage');\n    }\n  }\n\n  /**\n   * Maneja un evento recibido.\n   */\n  private handleEvent(event: AuthSyncEvent): void {\n    // Verificar que el evento no sea muy antiguo (más de 5 segundos)\n    const age = Date.now() - event.timestamp;\n    if (age > 5000) {\n      return;\n    }\n\n    this.eventSubject.next(event);\n  }\n}\n"]}

package/esm2022/lib/services/auth/token.service.mjs

@@ -0,0 +1,122 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para manejo de tokens JWT.
+ * Parseo y validación de tokens sin dependencias externas.
+ */
+export class TokenService {
+    /**
+     * Parsea un token JWT y extrae los claims.
+     * @param token - Token JWT
+     * @returns Claims del token o null si es inválido
+     */
+    parseToken(token) {
+        try {
+            const parts = token.split('.');
+            if (parts.length !== 3) {
+                return null;
+            }
+            const payload = parts[1];
+            const decoded = this.base64UrlDecode(payload);
+            return JSON.parse(decoded);
+        }
+        catch {
+            console.warn('[ValtechAuth] Error al parsear token JWT');
+            return null;
+        }
+    }
+    /**
+     * Verifica si un token es válido (no expirado).
+     * @param token - Token JWT
+     * @returns true si el token es válido
+     */
+    isTokenValid(token) {
+        const claims = this.parseToken(token);
+        if (!claims) {
+            return false;
+        }
+        // exp está en segundos, Date.now() en milisegundos
+        const expirationMs = claims.exp * 1000;
+        return Date.now() < expirationMs;
+    }
+    /**
+     * Obtiene el tiempo restante del token en segundos.
+     * @param token - Token JWT
+     * @returns Segundos restantes o 0 si expirado
+     */
+    getTimeToExpiry(token) {
+        const claims = this.parseToken(token);
+        if (!claims) {
+            return 0;
+        }
+        const expirationMs = claims.exp * 1000;
+        const remaining = expirationMs - Date.now();
+        return remaining > 0 ? Math.floor(remaining / 1000) : 0;
+    }
+    /**
+     * Obtiene el timestamp de expiración del token.
+     * @param token - Token JWT
+     * @returns Timestamp en milisegundos o null
+     */
+    getExpirationTime(token) {
+        const claims = this.parseToken(token);
+        if (!claims) {
+            return null;
+        }
+        return claims.exp * 1000;
+    }
+    /**
+     * Extrae el user ID del token.
+     * @param token - Token JWT
+     * @returns User ID o null
+     */
+    getUserId(token) {
+        const claims = this.parseToken(token);
+        return claims?.uid || null;
+    }
+    /**
+     * Extrae el email del token.
+     * @param token - Token JWT
+     * @returns Email o null
+     */
+    getEmail(token) {
+        const claims = this.parseToken(token);
+        return claims?.email || null;
+    }
+    /**
+     * Extrae el estado premium del token.
+     * @param token - Token JWT
+     * @returns true si el usuario es premium
+     */
+    isPremium(token) {
+        const claims = this.parseToken(token);
+        return claims?.premium === true;
+    }
+    /**
+     * Decodifica base64url a string.
+     * Base64url usa - y _ en lugar de + y /
+     */
+    base64UrlDecode(str) {
+        // Reemplazar caracteres base64url por base64 estándar
+        let base64 = str.replace(/-/g, '+').replace(/_/g, '/');
+        // Agregar padding si es necesario
+        const padding = base64.length % 4;
+        if (padding) {
+            base64 += '='.repeat(4 - padding);
+        }
+        // Decodificar
+        const decoded = atob(base64);
+        // Manejar caracteres UTF-8
+        return decodeURIComponent(decoded
+            .split('')
+            .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+            .join(''));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TokenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TokenService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TokenService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/token.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAG3C;;;GAGG;AAEH,MAAM,OAAO,YAAY;IACvB;;;;OAIG;IACH,UAAU,CAAC,KAAa;QACtB,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACvB,OAAO,IAAI,CAAC;YACd,CAAC;YAED,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACzB,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,CAAC,IAAI,CAAC,0CAA0C,CAAC,CAAC;YACzD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,YAAY,CAAC,KAAa;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QAED,mDAAmD;QACnD,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC;QACvC,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACH,eAAe,CAAC,KAAa;QAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,CAAC,CAAC;QACX,CAAC;QAED,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC;QACvC,MAAM,SAAS,GAAG,YAAY,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC5C,OAAO,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,CAAC;IAED;;;;OAIG;IACH,iBAAiB,CAAC,KAAa;QAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,KAAa;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACtC,OAAO,MAAM,EAAE,GAAG,IAAI,IAAI,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,KAAa;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACtC,OAAO,MAAM,EAAE,KAAK,IAAI,IAAI,CAAC;IAC/B,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,KAAa;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACtC,OAAO,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAClC,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,GAAW;QACjC,sDAAsD;QACtD,IAAI,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAEvD,kCAAkC;QAClC,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;QAClC,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;QACpC,CAAC;QAED,cAAc;QACd,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QAE7B,2BAA2B;QAC3B,OAAO,kBAAkB,CACvB,OAAO;aACJ,KAAK,CAAC,EAAE,CAAC;aACT,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;aACjE,IAAI,CAAC,EAAE,CAAC,CACZ,CAAC;IACJ,CAAC;+GA1HU,YAAY;mHAAZ,YAAY,cADC,MAAM;;4FACnB,YAAY;kBADxB,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable } from '@angular/core';\nimport { JWTClaims } from './types';\n\n/**\n * Servicio para manejo de tokens JWT.\n * Parseo y validación de tokens sin dependencias externas.\n */\n@Injectable({ providedIn: 'root' })\nexport class TokenService {\n  /**\n   * Parsea un token JWT y extrae los claims.\n   * @param token - Token JWT\n   * @returns Claims del token o null si es inválido\n   */\n  parseToken(token: string): JWTClaims | null {\n    try {\n      const parts = token.split('.');\n      if (parts.length !== 3) {\n        return null;\n      }\n\n      const payload = parts[1];\n      const decoded = this.base64UrlDecode(payload);\n      return JSON.parse(decoded);\n    } catch {\n      console.warn('[ValtechAuth] Error al parsear token JWT');\n      return null;\n    }\n  }\n\n  /**\n   * Verifica si un token es válido (no expirado).\n   * @param token - Token JWT\n   * @returns true si el token es válido\n   */\n  isTokenValid(token: string): boolean {\n    const claims = this.parseToken(token);\n    if (!claims) {\n      return false;\n    }\n\n    // exp está en segundos, Date.now() en milisegundos\n    const expirationMs = claims.exp * 1000;\n    return Date.now() < expirationMs;\n  }\n\n  /**\n   * Obtiene el tiempo restante del token en segundos.\n   * @param token - Token JWT\n   * @returns Segundos restantes o 0 si expirado\n   */\n  getTimeToExpiry(token: string): number {\n    const claims = this.parseToken(token);\n    if (!claims) {\n      return 0;\n    }\n\n    const expirationMs = claims.exp * 1000;\n    const remaining = expirationMs - Date.now();\n    return remaining > 0 ? Math.floor(remaining / 1000) : 0;\n  }\n\n  /**\n   * Obtiene el timestamp de expiración del token.\n   * @param token - Token JWT\n   * @returns Timestamp en milisegundos o null\n   */\n  getExpirationTime(token: string): number | null {\n    const claims = this.parseToken(token);\n    if (!claims) {\n      return null;\n    }\n\n    return claims.exp * 1000;\n  }\n\n  /**\n   * Extrae el user ID del token.\n   * @param token - Token JWT\n   * @returns User ID o null\n   */\n  getUserId(token: string): string | null {\n    const claims = this.parseToken(token);\n    return claims?.uid || null;\n  }\n\n  /**\n   * Extrae el email del token.\n   * @param token - Token JWT\n   * @returns Email o null\n   */\n  getEmail(token: string): string | null {\n    const claims = this.parseToken(token);\n    return claims?.email || null;\n  }\n\n  /**\n   * Extrae el estado premium del token.\n   * @param token - Token JWT\n   * @returns true si el usuario es premium\n   */\n  isPremium(token: string): boolean {\n    const claims = this.parseToken(token);\n    return claims?.premium === true;\n  }\n\n  /**\n   * Decodifica base64url a string.\n   * Base64url usa - y _ en lugar de + y /\n   */\n  private base64UrlDecode(str: string): string {\n    // Reemplazar caracteres base64url por base64 estándar\n    let base64 = str.replace(/-/g, '+').replace(/_/g, '/');\n\n    // Agregar padding si es necesario\n    const padding = base64.length % 4;\n    if (padding) {\n      base64 += '='.repeat(4 - padding);\n    }\n\n    // Decodificar\n    const decoded = atob(base64);\n\n    // Manejar caracteres UTF-8\n    return decodeURIComponent(\n      decoded\n        .split('')\n        .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))\n        .join('')\n    );\n  }\n}\n"]}

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

@@ -0,0 +1,30 @@
+/**
+ * Tipos e interfaces para el servicio de autenticación de Valtech.
+ * Alineados con el backend AuthV2.
+ */
+/**
+ * Estado inicial de autenticación.
+ */
+export const INITIAL_AUTH_STATE = {
+    isAuthenticated: false,
+    isLoading: true,
+    accessToken: null,
+    refreshToken: null,
+    userId: null,
+    email: null,
+    roles: [],
+    permissions: [],
+    isSuperAdmin: false,
+    isPremium: false,
+    expiresAt: null,
+    error: null,
+};
+/**
+ * Estado inicial de MFA.
+ */
+export const INITIAL_MFA_STATE = {
+    required: false,
+    mfaToken: null,
+    method: null,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA6FH;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAc;IAC3C,eAAe,EAAE,KAAK;IACtB,SAAS,EAAE,IAAI;IACf,WAAW,EAAE,IAAI;IACjB,YAAY,EAAE,IAAI;IAClB,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,EAAE;IACT,WAAW,EAAE,EAAE;IACf,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE,KAAK;IAChB,SAAS,EAAE,IAAI;IACf,KAAK,EAAE,IAAI;CACZ,CAAC;AAkBF;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAoB;IAChD,QAAQ,EAAE,KAAK;IACf,QAAQ,EAAE,IAAI;IACd,MAAM,EAAE,IAAI;CACb,CAAC","sourcesContent":["/**\n * Tipos e interfaces para el servicio de autenticación de Valtech.\n * Alineados con el backend AuthV2.\n */\n\n// =============================================================================\n// CONFIGURACIÓN\n// =============================================================================\n\n/**\n * Configuración para el servicio de autenticación.\n */\nexport interface ValtechAuthConfig {\n  /** URL base de la API (ej: 'https://api.myvaltech.com') */\n  apiUrl: string;\n  /** Prefijo para endpoints de auth (default: '/v2/auth') */\n  authPrefix?: string;\n  /** Prefijo para las claves de localStorage (default: 'valtech_auth_') */\n  storagePrefix?: string;\n  /** Tiempo antes de expiración para refrescar token en segundos (default: 60) */\n  refreshBeforeExpiry?: number;\n  /** Habilitar sincronización entre pestañas (default: true) */\n  enableTabSync?: boolean;\n  /** Ruta de redirección cuando no autenticado (default: '/login') */\n  loginRoute?: string;\n  /** Ruta de redirección cuando ya autenticado (default: '/') */\n  homeRoute?: string;\n  /** Ruta para acceso denegado (default: '/unauthorized') */\n  unauthorizedRoute?: string;\n  /** Habilitar integración con FirebaseService (default: false) */\n  enableFirebaseIntegration?: boolean;\n  /** Habilitar registro automático de device tokens para push notifications (default: false) */\n  enableDeviceRegistration?: boolean;\n}\n\n// =============================================================================\n// ESTADO DE AUTENTICACIÓN\n// =============================================================================\n\n/**\n * Estado completo de autenticación.\n */\nexport interface AuthState {\n  /** Usuario está autenticado */\n  isAuthenticated: boolean;\n  /** Estado de carga inicial */\n  isLoading: boolean;\n  /** Token de acceso actual */\n  accessToken: string | null;\n  /** Token de refresco actual */\n  refreshToken: string | null;\n  /** ID del usuario */\n  userId: string | null;\n  /** Email del usuario */\n  email: string | null;\n  /** Roles del usuario */\n  roles: string[];\n  /** Permisos del usuario (formato 'resource:action') */\n  permissions: string[];\n  /** Usuario es super admin */\n  isSuperAdmin: boolean;\n  /** Usuario tiene suscripción premium activa (no ve ads) */\n  isPremium: boolean;\n  /** Timestamp de expiración del accessToken (ms) */\n  expiresAt: number | null;\n  /** Error de autenticación (si existe) */\n  error: AuthError | null;\n}\n\n/**\n * Información del usuario autenticado.\n */\nexport interface AuthUser {\n  userId: string;\n  email: string;\n  name?: string;\n  phone?: string;\n  /** Username/handle del usuario (ej: @victorv) */\n  handle?: string;\n  /** URL del avatar del usuario */\n  avatarUrl?: string;\n  roles: string[];\n  permissions: string[];\n  isSuperAdmin: boolean;\n  mfaEnabled?: boolean;\n  mfaMethod?: MFAMethod;\n}\n\n/**\n * Error de autenticación.\n */\nexport interface AuthError {\n  code: string;\n  message: string;\n}\n\n/**\n * Estado inicial de autenticación.\n */\nexport const INITIAL_AUTH_STATE: AuthState = {\n  isAuthenticated: false,\n  isLoading: true,\n  accessToken: null,\n  refreshToken: null,\n  userId: null,\n  email: null,\n  roles: [],\n  permissions: [],\n  isSuperAdmin: false,\n  isPremium: false,\n  expiresAt: null,\n  error: null,\n};\n\n// =============================================================================\n// MFA\n// =============================================================================\n\n/** Métodos de MFA soportados */\nexport type MFAMethod = 'EMAIL' | 'SMS' | 'TOTP';\n\n/**\n * Estado de MFA pendiente.\n */\nexport interface MFAPendingState {\n  required: boolean;\n  mfaToken: string | null;\n  method: MFAMethod | null;\n}\n\n/**\n * Estado inicial de MFA.\n */\nexport const INITIAL_MFA_STATE: MFAPendingState = {\n  required: false,\n  mfaToken: null,\n  method: null,\n};\n\n/**\n * Resultado de setup de MFA.\n */\nexport interface MFASetupResult {\n  codeSent: boolean;\n  message: string;\n}\n\n/**\n * Estado de MFA del usuario.\n */\nexport interface MFAStatus {\n  enabled: boolean;\n  method: MFAMethod | null;\n}\n\n// =============================================================================\n// TOTP MFA (Google Authenticator)\n// =============================================================================\n\n/**\n * Response de setup de TOTP.\n */\nexport interface TOTPSetupResponse {\n  operationId: string;\n  /** Secreto TOTP en base32 (para entrada manual) */\n  secret: string;\n  /** URL para generar QR code (otpauth://...) */\n  qrCodeUrl: string;\n  /** Códigos de respaldo de un solo uso */\n  backupCodes: string[];\n  message: string;\n}\n\n/**\n * Request para verificar setup de TOTP.\n */\nexport interface TOTPVerifySetupRequest {\n  /** Código TOTP de 6 dígitos */\n  code: string;\n}\n\n/**\n * Response de verificación de setup TOTP.\n */\nexport interface TOTPVerifySetupResponse {\n  operationId: string;\n  enabled: boolean;\n  message: string;\n}\n\n/**\n * Request para deshabilitar TOTP.\n */\nexport interface TOTPDisableRequest {\n  password: string;\n}\n\n/**\n * Response de deshabilitar TOTP.\n */\nexport interface TOTPDisableResponse {\n  operationId: string;\n  disabled: boolean;\n  message: string;\n}\n\n/**\n * Response de regenerar códigos de respaldo.\n */\nexport interface RegenerateBackupCodesResponse {\n  operationId: string;\n  backupCodes: string[];\n  message: string;\n}\n\n/**\n * Response de cantidad de códigos de respaldo.\n */\nexport interface BackupCodesCountResponse {\n  operationId: string;\n  count: number;\n}\n\n// =============================================================================\n// REQUESTS/RESPONSES (alineados con backend AuthV2)\n// =============================================================================\n\n/**\n * Request para signup (registro).\n */\nexport interface SignupRequest {\n  email: string;\n  password: string;\n  name: string;\n  phone?: string;\n}\n\n/**\n * Response de signup (registro).\n */\nexport interface SignupResponse {\n  operationId: string;\n  userId: string;\n  message: string;\n}\n\n/**\n * Request para verificar email.\n */\nexport interface VerifyEmailRequest {\n  email: string;\n  code: string;\n}\n\n/**\n * Response de verificación de email.\n * Si es exitoso, incluye tokens para auto-login.\n */\nexport interface VerifyEmailResponse {\n  operationId: string;\n  verified: boolean;\n  accessToken?: string;\n  refreshToken?: string;\n  firebaseToken?: string;\n  expiresIn?: number;\n  tokenType?: string;\n}\n\n/**\n * Request para reenviar código de verificación.\n */\nexport interface ResendCodeRequest {\n  email: string;\n  type: 'EMAIL_VERIFY' | 'PASSWORD_RESET';\n}\n\n/**\n * Response de reenvío de código.\n */\nexport interface ResendCodeResponse {\n  operationId: string;\n  sent: boolean;\n}\n\n/**\n * Request para signin.\n */\nexport interface SigninRequest {\n  email: string;\n  password: string;\n  /** Plataforma del dispositivo (para detección de nuevo dispositivo) */\n  platform?: DevicePlatform;\n  /** Navegador (solo web) */\n  browser?: string;\n  /** Sistema operativo */\n  os?: string;\n  /** Nombre amigable del dispositivo */\n  deviceName?: string;\n}\n\n/**\n * Response de signin.\n */\nexport interface SigninResponse {\n  operationId: string;\n  accessToken?: string;\n  refreshToken?: string;\n  firebaseToken?: string;\n  expiresIn?: number;\n  tokenType?: string;\n  mfaRequired?: boolean;\n  mfaToken?: string;\n  mfaMethod?: MFAMethod;\n  roles?: string[];\n  permissions?: string[];\n  /** Indica si el login fue desde un dispositivo nuevo/no reconocido */\n  isNewDevice?: boolean;\n  /** ID del dispositivo usado para el login */\n  deviceId?: string;\n  /** Idioma preferido del usuario (para sincronizar con i18n) */\n  language?: string;\n}\n\n/**\n * Request para verificar MFA.\n */\nexport interface MFAVerifyRequest {\n  mfaToken: string;\n  code: string;\n}\n\n/**\n * Response de verificar MFA.\n */\nexport interface MFAVerifyResponse {\n  operationId: string;\n  accessToken: string;\n  refreshToken: string;\n  firebaseToken?: string;\n  expiresIn: number;\n  tokenType: string;\n  roles?: string[];\n  permissions?: string[];\n  /** Idioma preferido del usuario (para sincronizar con i18n) */\n  language?: string;\n}\n\n/**\n * Request para refrescar token.\n */\nexport interface RefreshRequest {\n  refreshToken: string;\n}\n\n/**\n * Response de refrescar token.\n * Implementa token rotation: cada refresh genera un nuevo refresh token.\n */\nexport interface RefreshResponse {\n  operationId: string;\n  accessToken: string;\n  refreshToken: string; // Token rotation: nuevo refresh token\n  expiresIn: number;\n  firebaseToken?: string;\n  roles?: string[];\n  permissions?: string[];\n}\n\n/**\n * Request para logout.\n */\nexport interface LogoutRequest {\n  refreshToken: string;\n}\n\n/**\n * Response de logout.\n */\nexport interface LogoutResponse {\n  operationId: string;\n  success: boolean;\n}\n\n/**\n * Response de obtener permisos.\n */\nexport interface GetPermissionsResponse {\n  operationId: string;\n  roles: string[];\n  permissions: string[];\n  isSuperAdmin: boolean;\n}\n\n/**\n * Request para setup de MFA.\n */\nexport interface MFASetupRequest {\n  method: MFAMethod;\n  phone?: string;\n}\n\n/**\n * Response de setup de MFA.\n */\nexport interface MFASetupResponse {\n  operationId: string;\n  codeSent: boolean;\n  message: string;\n}\n\n/**\n * Request para confirmar MFA.\n */\nexport interface MFAConfirmRequest {\n  code: string;\n}\n\n/**\n * Response de confirmar MFA.\n */\nexport interface MFAConfirmResponse {\n  operationId: string;\n  mfaEnabled: boolean;\n  method: MFAMethod;\n}\n\n/**\n * Request para deshabilitar MFA.\n */\nexport interface MFADisableRequest {\n  password: string;\n}\n\n/**\n * Response de deshabilitar MFA.\n */\nexport interface MFADisableResponse {\n  operationId: string;\n  mfaDisabled: boolean;\n}\n\n/**\n * Request para iniciar recuperación de contraseña.\n */\nexport interface ForgotPasswordRequest {\n  email: string;\n}\n\n/**\n * Response de forgot password (siempre igual por seguridad).\n */\nexport interface ForgotPasswordResponse {\n  operationId: string;\n  message: string;\n}\n\n/**\n * Request para resetear contraseña con código.\n */\nexport interface ResetPasswordRequest {\n  email: string;\n  code: string;\n  newPassword: string;\n}\n\n/**\n * Response de reset password.\n */\nexport interface ResetPasswordResponse {\n  operationId: string;\n  success: boolean;\n}\n\n/**\n * Request para cambiar contraseña (usuario autenticado).\n */\nexport interface ChangePasswordRequest {\n  currentPassword: string;\n  newPassword: string;\n}\n\n/**\n * Response de cambio de contraseña.\n */\nexport interface ChangePasswordResponse {\n  operationId: string;\n  success: boolean;\n}\n\n/**\n * Request para eliminar cuenta (requiere confirmación de contraseña).\n */\nexport interface DeleteAccountRequest {\n  password: string;\n}\n\n/**\n * Response de eliminar cuenta.\n */\nexport interface DeleteAccountResponse {\n  operationId: string;\n  deleted: boolean;\n  message: string;\n}\n\n/**\n * Response de obtener perfil del usuario.\n */\nexport interface GetProfileResponse {\n  operationId: string;\n  userId: string;\n  email: string;\n  name: string;\n  phone?: string;\n  /** Username/handle del usuario */\n  handle?: string;\n  /** URL del avatar del usuario */\n  avatarUrl?: string;\n  emailVerified: boolean;\n  phoneVerified: boolean;\n  mfaEnabled: boolean;\n  mfaMethod?: MFAMethod;\n  createdAt: string;\n  updatedAt: string;\n}\n\n/**\n * Request para actualizar perfil.\n */\nexport interface UpdateProfileRequest {\n  name?: string;\n  phone?: string;\n}\n\n/**\n * Response de actualizar perfil.\n */\nexport interface UpdateProfileResponse {\n  operationId: string;\n  updated: boolean;\n}\n\n// =============================================================================\n// UPDATE AVATAR\n// =============================================================================\n\n/**\n * Request para actualizar avatar del usuario.\n */\nexport interface UpdateAvatarRequest {\n  /** URL del avatar en Firebase Storage */\n  avatarUrl: string;\n  /** URL del thumbnail (opcional) */\n  avatarThumbnail?: string;\n}\n\n/**\n * Response de actualizar avatar.\n */\nexport interface UpdateAvatarResponse {\n  operationId: string;\n  avatarUrl: string;\n  avatarThumbnail?: string;\n  updatedAt: string;\n}\n\n// =============================================================================\n// EVENTOS DE SINCRONIZACIÓN\n// =============================================================================\n\n// =============================================================================\n// SWITCH ORGANIZATION\n// =============================================================================\n\n/**\n * Request para cambiar de organización activa.\n */\nexport interface SwitchOrgRequest {\n  organizationId: string;\n}\n\n/**\n * Response de cambio de organización.\n */\nexport interface SwitchOrgResponse {\n  operationId: string;\n  firebaseToken: string;\n  activeOrg: string;\n}\n\n// =============================================================================\n// EVENTOS DE SINCRONIZACIÓN\n// =============================================================================\n\n/** Tipos de eventos de sincronización entre pestañas */\nexport type AuthSyncEventType =\n  | 'LOGIN'\n  | 'LOGOUT'\n  | 'TOKEN_REFRESH'\n  | 'PERMISSIONS_UPDATE'\n  | 'ORG_SWITCH';\n\n/**\n * Evento de sincronización entre pestañas.\n */\nexport interface AuthSyncEvent {\n  type: AuthSyncEventType;\n  timestamp: number;\n  payload?: {\n    accessToken?: string;\n    refreshToken?: string; // Token rotation support\n    expiresAt?: number;\n    activeOrg?: string;\n  };\n}\n\n// =============================================================================\n// JWT CLAIMS\n// =============================================================================\n\n/**\n * Claims del JWT de acceso.\n */\nexport interface JWTClaims {\n  /** User ID */\n  uid: string;\n  /** Email */\n  email: string;\n  /** Session ID */\n  sid?: string;\n  /** Usuario tiene suscripción premium activa */\n  premium?: boolean;\n  /** Issued at */\n  iat: number;\n  /** Expiration */\n  exp: number;\n}\n\n// =============================================================================\n// STORAGE\n// =============================================================================\n\n/**\n * Datos persistidos en storage.\n */\nexport interface StoredAuthState {\n  accessToken: string;\n  refreshToken: string;\n  roles: string[];\n  permissions: string[];\n  isSuperAdmin: boolean;\n  isPremium?: boolean;\n  expiresAt?: number;\n}\n\n// =============================================================================\n// DEVICE REGISTRATION (Push Notifications)\n// =============================================================================\n\n/**\n * Plataformas soportadas para push notifications.\n */\nexport type DevicePlatform = 'web' | 'ios' | 'android';\n\n/**\n * Request para registrar un dispositivo.\n */\nexport interface RegisterDeviceRequest {\n  /** FCM token del dispositivo */\n  token: string;\n  /** Plataforma del dispositivo */\n  platform: DevicePlatform;\n  /** Navegador (solo web) */\n  browser?: string;\n  /** Sistema operativo */\n  os?: string;\n  /** Versión de la aplicación */\n  appVersion?: string;\n  /** Nombre amigable del dispositivo */\n  name?: string;\n  /** Metadata adicional */\n  metadata?: Record<string, string>;\n}\n\n/**\n * Response de registro de dispositivo.\n */\nexport interface RegisterDeviceResponse {\n  operationId: string;\n  device: {\n    deviceId: string;\n    token: string;\n    platform: DevicePlatform;\n    browser?: string;\n    os?: string;\n    lastActive: string;\n    createdAt: string;\n  };\n  /** true si es un nuevo dispositivo, false si se actualizó uno existente */\n  isNew: boolean;\n}\n\n/**\n * Resultado de habilitar notificaciones.\n */\nexport interface EnableNotificationsResult {\n  /** Si se otorgaron los permisos */\n  granted: boolean;\n  /** FCM token (solo si granted=true) */\n  token?: string;\n  /** Si el dispositivo fue registrado en el backend */\n  registered?: boolean;\n}\n\n/**\n * Estado de permisos de notificación.\n */\nexport type NotificationPermissionState = 'granted' | 'denied' | 'default' | 'unsupported';\n\n/**\n * Resultado del registro manual de dispositivo.\n */\nexport interface RegisterDeviceResult {\n  /** Si el dispositivo fue registrado exitosamente */\n  registered: boolean;\n  /** ID del dispositivo (solo si registered=true) */\n  deviceId?: string;\n  /** FCM token usado para el registro */\n  token?: string;\n  /** Mensaje de error (solo si registered=false) */\n  error?: string;\n}\n\n// =============================================================================\n// DEVICE MANAGEMENT (Detección de dispositivos nuevos)\n// =============================================================================\n\n/**\n * Estados posibles de un dispositivo.\n */\nexport type DeviceStatus = 'active' | 'pending_approval' | 'blocked';\n\n/**\n * Información completa de un dispositivo registrado.\n */\nexport interface DeviceInfo {\n  /** ID único del dispositivo */\n  deviceId: string;\n  /** Plataforma del dispositivo */\n  platform: DevicePlatform;\n  /** Navegador (solo web) */\n  browser?: string;\n  /** Sistema operativo */\n  os?: string;\n  /** Nombre amigable del dispositivo */\n  name?: string;\n  /** Estado actual del dispositivo */\n  status: DeviceStatus;\n  /** Dirección IP del último acceso */\n  ipAddress?: string;\n  /** Ubicación geográfica aproximada */\n  location?: string;\n  /** Última actividad */\n  lastActive: string;\n  /** Fecha de creación/registro */\n  createdAt: string;\n  /** Fecha de aprobación (si aplica) */\n  approvedAt?: string;\n  /** Fecha de bloqueo (si aplica) */\n  blockedAt?: string;\n}\n\n/**\n * Response de listar dispositivos del usuario.\n */\nexport interface ListDevicesResponse {\n  operationId: string;\n  devices: DeviceInfo[];\n}\n\n/**\n * Response de acción sobre dispositivo (block/approve/delete).\n */\nexport interface DeviceActionResult {\n  operationId: string;\n  success: boolean;\n  message: string;\n}\n\n// =============================================================================\n// SESSION MANAGEMENT (Gestión de sesiones activas)\n// =============================================================================\n\n/**\n * Información de una sesión activa.\n */\nexport interface SessionInfo {\n  /** ID único de la sesión */\n  sessionId: string;\n  /** ID del dispositivo asociado (si existe) */\n  deviceId?: string;\n  /** Información del dispositivo (User-Agent) */\n  deviceInfo?: string;\n  /** Dirección IP de la sesión */\n  ip?: string;\n  /** Ubicación geográfica aproximada */\n  location?: string;\n  /** Fecha de creación de la sesión */\n  createdAt: string;\n  /** Fecha de expiración de la sesión */\n  expiresAt: string;\n  /** Indica si es la sesión actual del usuario */\n  isCurrent: boolean;\n}\n\n/**\n * Response de listar sesiones activas.\n */\nexport interface ListSessionsResponse {\n  operationId: string;\n  sessions: SessionInfo[];\n}\n\n/**\n * Response de revocar sesión(es).\n */\nexport interface RevokeSessionsResponse {\n  operationId: string;\n  success: boolean;\n  /** Número de sesiones revocadas */\n  sessionsRevoked: number;\n}\n\n// =============================================================================\n// DEVICE ACTION (Acciones desde email de alerta)\n// =============================================================================\n\n/**\n * Request para ejecutar acción de dispositivo desde email.\n * El token viene en la URL del email de alerta.\n */\nexport interface DeviceActionRequest {\n  /** Token JWT de acción (24h, un solo uso) */\n  token: string;\n}\n\n/**\n * Response de ejecutar acción de dispositivo.\n */\nexport interface DeviceActionResponse {\n  operationId: string;\n  /** Si la acción fue ejecutada exitosamente */\n  success: boolean;\n  /** Acción ejecutada (refuse, approve, block) */\n  action: string;\n  /** ID del dispositivo afectado */\n  deviceId: string;\n  /** Número de sesiones revocadas (si action=refuse/block) */\n  sessionsRevoked?: number;\n  /** Mensaje descriptivo */\n  message: string;\n}\n\n/**\n * Response de validar token de acción (sin ejecutar).\n * Usado para mostrar confirmación al usuario antes de ejecutar.\n */\nexport interface ValidateActionResponse {\n  operationId: string;\n  /** Si el token es válido */\n  valid: boolean;\n  /** Tipo de acción (device:refuse, device:approve, etc.) */\n  actionType?: string;\n  /** Tipo de recurso objetivo (device, document, etc.) */\n  targetType?: string;\n  /** ID del recurso objetivo */\n  targetId?: string;\n  /** Mensaje de error (si valid=false) */\n  message?: string;\n}\n\n// =============================================================================\n// OAUTH (Login social)\n// =============================================================================\n\n/**\n * Proveedores OAuth soportados.\n */\nexport type OAuthProvider = 'google' | 'apple' | 'microsoft';\n\n/**\n * Resultado exitoso de flujo OAuth.\n */\nexport interface OAuthResult {\n  /** Token de acceso JWT */\n  accessToken: string;\n  /** Token de refresco */\n  refreshToken: string;\n  /** Token de Firebase (si está habilitado) */\n  firebaseToken?: string;\n  /** Tiempo de expiración en segundos */\n  expiresIn: number;\n  /** Roles del usuario */\n  roles?: string[];\n  /** Permisos del usuario */\n  permissions?: string[];\n  /** Indica si es un usuario nuevo (recién creado) */\n  isNewUser?: boolean;\n  /** Indica si la cuenta fue vinculada a usuario existente */\n  linked?: boolean;\n}\n\n/**\n * Error de OAuth.\n */\nexport interface OAuthError {\n  /** Código de error */\n  code: string;\n  /** Mensaje descriptivo */\n  message: string;\n}\n\n/**\n * Datos enviados desde popup callback via postMessage.\n */\nexport interface OAuthCallbackData {\n  /** Tipo de mensaje */\n  type: 'oauth-callback';\n  /** Tokens (si éxito) */\n  tokens?: OAuthResult;\n  /** Error (si falló) */\n  error?: OAuthError;\n}\n\n/**\n * Proveedor OAuth vinculado al usuario.\n */\nexport interface LinkedProvider {\n  /** Nombre del proveedor */\n  provider: OAuthProvider;\n  /** Email asociado al proveedor */\n  email: string;\n  /** Nombre del usuario en el proveedor */\n  name?: string;\n  /** URL de imagen de perfil */\n  picture?: string;\n  /** Fecha de vinculación */\n  linkedAt: string;\n  /** Última vez que se usó para login */\n  lastUsedAt?: string;\n}\n\n/**\n * Response de verificar si tiene contraseña.\n */\nexport interface HasPasswordResponse {\n  operationId: string;\n  hasPassword: boolean;\n}\n\n// =============================================================================\n// HANDLE (Username)\n// =============================================================================\n\n/**\n * Request para actualizar handle (@username).\n */\nexport interface UpdateHandleRequest {\n  handle: string;\n}\n\n/**\n * Response de actualizar handle.\n */\nexport interface UpdateHandleResponse {\n  operationId: string;\n  handle: string;\n  updated: boolean;\n}\n\n/**\n * Request para verificar disponibilidad de handle.\n */\nexport interface CheckHandleRequest {\n  handle: string;\n}\n\n/**\n * Response de verificar disponibilidad de handle.\n */\nexport interface CheckHandleResponse {\n  operationId: string;\n  handle: string;\n  available: boolean;\n}\n\n// =============================================================================\n// LINKED PROVIDERS (OAuth)\n// =============================================================================\n\n/**\n * Response de obtener proveedores OAuth vinculados.\n */\nexport interface GetLinkedProvidersResponse {\n  operationId: string;\n  providers: LinkedProvider[];\n}\n\n/**\n * Request para desvincular un proveedor OAuth.\n */\nexport interface UnlinkProviderRequest {\n  provider: OAuthProvider;\n}\n\n/**\n * Response de desvincular proveedor.\n */\nexport interface UnlinkProviderResponse {\n  operationId: string;\n  unlinked: boolean;\n}\n\n"]}

package/esm2022/lib/services/confirmation-dialog/confirmation-dialog.service.mjs

@@ -0,0 +1,180 @@
+import { Injectable, inject } from '@angular/core';
+import { AlertController } from '@ionic/angular/standalone';
+import { DEFAULT_CONFIRM_BUTTON, DEFAULT_CANCEL_BUTTON, } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Service for displaying confirmation dialogs.
+ *
+ * @example Basic usage
+ * const result = await confirmationService.confirm({
+ *   title: 'Delete Item',
+ *   message: 'Are you sure you want to delete this item?',
+ * });
+ *
+ * if (result.confirmed) {
+ *   // User confirmed
+ * }
+ *
+ * @example Custom buttons
+ * const result = await confirmationService.confirm({
+ *   title: 'Save Changes',
+ *   message: 'Do you want to save your changes before leaving?',
+ *   confirmButton: { text: 'Save', color: 'success' },
+ *   cancelButton: { text: 'Discard', color: 'danger' },
+ *   extraButtons: [{ text: 'Cancel', role: 'cancel' }]
+ * });
+ *
+ * @example Destructive action
+ * const result = await confirmationService.confirmDestructive({
+ *   title: 'Delete Account',
+ *   message: 'This action cannot be undone. Are you sure?',
+ * });
+ */
+export class ConfirmationDialogService {
+    constructor() {
+        this.alertController = inject(AlertController);
+    }
+    /**
+     * Shows a confirmation dialog and returns the result.
+     * @param options - Configuration for the dialog
+     * @returns Promise resolving to the confirmation result
+     */
+    async confirm(options) {
+        const buttons = this.buildButtons(options);
+        const alert = await this.alertController.create({
+            header: options.title,
+            subHeader: options.subHeader,
+            message: options.message,
+            buttons,
+            backdropDismiss: options.backdropDismiss ?? false,
+            cssClass: options.cssClass,
+            mode: options.mode,
+            translucent: options.translucent ?? false,
+            animated: options.animated ?? true,
+        });
+        await alert.present();
+        const { role, data } = await alert.onDidDismiss();
+        return {
+            confirmed: role === 'confirm',
+            role,
+            data,
+        };
+    }
+    /**
+     * Shows a simple confirmation dialog with default buttons.
+     * @param title - Dialog title
+     * @param message - Dialog message
+     * @returns Promise resolving to true if confirmed, false otherwise
+     */
+    async confirmSimple(title, message) {
+        const result = await this.confirm({ title, message });
+        return result.confirmed;
+    }
+    /**
+     * Shows a destructive action confirmation with red confirm button.
+     * @param options - Configuration for the dialog
+     * @returns Promise resolving to the confirmation result
+     */
+    async confirmDestructive(options) {
+        return this.confirm({
+            ...options,
+            confirmButton: {
+                text: options.confirmButton?.text || 'Delete',
+                role: 'destructive',
+                color: 'danger',
+                cssClass: 'destructive-button',
+                ...options.confirmButton,
+            },
+        });
+    }
+    /**
+     * Shows an info alert with just an OK button.
+     * @param title - Alert title
+     * @param message - Alert message
+     */
+    async alert(title, message) {
+        const alert = await this.alertController.create({
+            header: title,
+            message,
+            buttons: [{ text: 'OK', role: 'confirm' }],
+        });
+        await alert.present();
+        await alert.onDidDismiss();
+    }
+    /**
+     * Shows a three-option dialog (Save, Discard, Cancel).
+     * Common for unsaved changes scenarios.
+     * @param title - Dialog title
+     * @param message - Dialog message
+     * @returns Promise resolving to 'save' | 'discard' | 'cancel'
+     */
+    async confirmSaveDiscard(title, message) {
+        const alert = await this.alertController.create({
+            header: title,
+            message,
+            backdropDismiss: false,
+            buttons: [
+                {
+                    text: 'Cancel',
+                    role: 'cancel',
+                },
+                {
+                    text: 'Discard',
+                    role: 'destructive',
+                    cssClass: 'text-danger',
+                },
+                {
+                    text: 'Save',
+                    role: 'confirm',
+                },
+            ],
+        });
+        await alert.present();
+        const { role } = await alert.onDidDismiss();
+        if (role === 'confirm')
+            return 'save';
+        if (role === 'destructive')
+            return 'discard';
+        return 'cancel';
+    }
+    buildButtons(options) {
+        const buttons = [];
+        // Cancel button
+        const cancelBtn = options.cancelButton || DEFAULT_CANCEL_BUTTON;
+        buttons.push({
+            text: cancelBtn.text,
+            role: cancelBtn.role || 'cancel',
+            cssClass: cancelBtn.cssClass || `button-${cancelBtn.color || 'medium'}`,
+            handler: cancelBtn.handler,
+        });
+        // Extra buttons (if any)
+        if (options.extraButtons) {
+            options.extraButtons.forEach((btn) => {
+                buttons.push({
+                    text: btn.text,
+                    role: btn.role,
+                    cssClass: btn.cssClass || `button-${btn.color || 'medium'}`,
+                    handler: btn.handler,
+                });
+            });
+        }
+        // Confirm button
+        const confirmBtn = options.confirmButton || DEFAULT_CONFIRM_BUTTON;
+        buttons.push({
+            text: confirmBtn.text,
+            role: confirmBtn.role || 'confirm',
+            cssClass: confirmBtn.cssClass || `button-${confirmBtn.color || 'primary'}`,
+            handler: confirmBtn.handler,
+        });
+        return buttons;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConfirmationDialogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConfirmationDialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConfirmationDialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confirmation-dialog.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/confirmation-dialog/confirmation-dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { AlertController } from '@ionic/angular/standalone';\nimport {\n  ConfirmationDialogMetadata,\n  ConfirmationResult,\n  ConfirmationButton,\n  DEFAULT_CONFIRM_BUTTON,\n  DEFAULT_CANCEL_BUTTON,\n} from './types';\n\n/**\n * Service for displaying confirmation dialogs.\n *\n * @example Basic usage\n * const result = await confirmationService.confirm({\n *   title: 'Delete Item',\n *   message: 'Are you sure you want to delete this item?',\n * });\n *\n * if (result.confirmed) {\n *   // User confirmed\n * }\n *\n * @example Custom buttons\n * const result = await confirmationService.confirm({\n *   title: 'Save Changes',\n *   message: 'Do you want to save your changes before leaving?',\n *   confirmButton: { text: 'Save', color: 'success' },\n *   cancelButton: { text: 'Discard', color: 'danger' },\n *   extraButtons: [{ text: 'Cancel', role: 'cancel' }]\n * });\n *\n * @example Destructive action\n * const result = await confirmationService.confirmDestructive({\n *   title: 'Delete Account',\n *   message: 'This action cannot be undone. Are you sure?',\n * });\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConfirmationDialogService {\n  private alertController = inject(AlertController);\n\n  /**\n   * Shows a confirmation dialog and returns the result.\n   * @param options - Configuration for the dialog\n   * @returns Promise resolving to the confirmation result\n   */\n  async confirm(options: ConfirmationDialogMetadata): Promise<ConfirmationResult> {\n    const buttons = this.buildButtons(options);\n\n    const alert = await this.alertController.create({\n      header: options.title,\n      subHeader: options.subHeader,\n      message: options.message,\n      buttons,\n      backdropDismiss: options.backdropDismiss ?? false,\n      cssClass: options.cssClass,\n      mode: options.mode,\n      translucent: options.translucent ?? false,\n      animated: options.animated ?? true,\n    });\n\n    await alert.present();\n    const { role, data } = await alert.onDidDismiss();\n\n    return {\n      confirmed: role === 'confirm',\n      role,\n      data,\n    };\n  }\n\n  /**\n   * Shows a simple confirmation dialog with default buttons.\n   * @param title - Dialog title\n   * @param message - Dialog message\n   * @returns Promise resolving to true if confirmed, false otherwise\n   */\n  async confirmSimple(title: string, message: string): Promise<boolean> {\n    const result = await this.confirm({ title, message });\n    return result.confirmed;\n  }\n\n  /**\n   * Shows a destructive action confirmation with red confirm button.\n   * @param options - Configuration for the dialog\n   * @returns Promise resolving to the confirmation result\n   */\n  async confirmDestructive(\n    options: Omit<ConfirmationDialogMetadata, 'confirmButton'> & {\n      confirmButton?: Partial<ConfirmationButton>;\n    }\n  ): Promise<ConfirmationResult> {\n    return this.confirm({\n      ...options,\n      confirmButton: {\n        text: options.confirmButton?.text || 'Delete',\n        role: 'destructive',\n        color: 'danger',\n        cssClass: 'destructive-button',\n        ...options.confirmButton,\n      },\n    });\n  }\n\n  /**\n   * Shows an info alert with just an OK button.\n   * @param title - Alert title\n   * @param message - Alert message\n   */\n  async alert(title: string, message: string): Promise<void> {\n    const alert = await this.alertController.create({\n      header: title,\n      message,\n      buttons: [{ text: 'OK', role: 'confirm' }],\n    });\n\n    await alert.present();\n    await alert.onDidDismiss();\n  }\n\n  /**\n   * Shows a three-option dialog (Save, Discard, Cancel).\n   * Common for unsaved changes scenarios.\n   * @param title - Dialog title\n   * @param message - Dialog message\n   * @returns Promise resolving to 'save' | 'discard' | 'cancel'\n   */\n  async confirmSaveDiscard(\n    title: string,\n    message: string\n  ): Promise<'save' | 'discard' | 'cancel'> {\n    const alert = await this.alertController.create({\n      header: title,\n      message,\n      backdropDismiss: false,\n      buttons: [\n        {\n          text: 'Cancel',\n          role: 'cancel',\n        },\n        {\n          text: 'Discard',\n          role: 'destructive',\n          cssClass: 'text-danger',\n        },\n        {\n          text: 'Save',\n          role: 'confirm',\n        },\n      ],\n    });\n\n    await alert.present();\n    const { role } = await alert.onDidDismiss();\n\n    if (role === 'confirm') return 'save';\n    if (role === 'destructive') return 'discard';\n    return 'cancel';\n  }\n\n  private buildButtons(options: ConfirmationDialogMetadata): any[] {\n    const buttons: any[] = [];\n\n    // Cancel button\n    const cancelBtn = options.cancelButton || DEFAULT_CANCEL_BUTTON;\n    buttons.push({\n      text: cancelBtn.text,\n      role: cancelBtn.role || 'cancel',\n      cssClass: cancelBtn.cssClass || `button-${cancelBtn.color || 'medium'}`,\n      handler: cancelBtn.handler,\n    });\n\n    // Extra buttons (if any)\n    if (options.extraButtons) {\n      options.extraButtons.forEach((btn) => {\n        buttons.push({\n          text: btn.text,\n          role: btn.role,\n          cssClass: btn.cssClass || `button-${btn.color || 'medium'}`,\n          handler: btn.handler,\n        });\n      });\n    }\n\n    // Confirm button\n    const confirmBtn = options.confirmButton || DEFAULT_CONFIRM_BUTTON;\n    buttons.push({\n      text: confirmBtn.text,\n      role: confirmBtn.role || 'confirm',\n      cssClass: confirmBtn.cssClass || `button-${confirmBtn.color || 'primary'}`,\n      handler: confirmBtn.handler,\n    });\n\n    return buttons;\n  }\n}\n"]}

package/esm2022/lib/services/confirmation-dialog/types.mjs

@@ -0,0 +1,14 @@
+/**
+ * Default confirmation dialog options.
+ */
+export const DEFAULT_CONFIRM_BUTTON = {
+    text: 'Confirm',
+    role: 'confirm',
+    color: 'primary',
+};
+export const DEFAULT_CANCEL_BUTTON = {
+    text: 'Cancel',
+    role: 'cancel',
+    color: 'medium',
+};
+//# sourceMappingURL=data:application/json;base64,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