valtech-components 2.0.689 → 2.0.690

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

@@ -0,0 +1,77 @@
+import { InjectionToken, makeEnvironmentProviders, APP_INITIALIZER, } from '@angular/core';
+import { provideHttpClient, withInterceptors } from '@angular/common/http';
+import { authInterceptor } from './interceptor';
+import { AuthService } from './auth.service';
+/**
+ * Token de inyección para la configuración de Auth.
+ */
+export const VALTECH_AUTH_CONFIG = new InjectionToken('ValtechAuthConfig');
+/**
+ * Configuración por defecto.
+ */
+export const DEFAULT_AUTH_CONFIG = {
+    authPrefix: '/v2/auth',
+    storagePrefix: 'valtech_auth_',
+    refreshBeforeExpiry: 60,
+    enableTabSync: true,
+    loginRoute: '/login',
+    homeRoute: '/',
+    unauthorizedRoute: '/unauthorized',
+    enableFirebaseIntegration: false,
+    enableDeviceRegistration: false,
+};
+/**
+ * Factory para inicializar el AuthService.
+ */
+function initializeAuth(authService) {
+    return () => authService.initialize();
+}
+/**
+ * Provee el servicio de autenticación a la aplicación Angular.
+ *
+ * @param config - Configuración de autenticación
+ * @returns EnvironmentProviders para usar en bootstrapApplication
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { provideValtechAuth } from 'valtech-components';
+ * import { environment } from './environments/environment';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechAuth({
+ *       apiUrl: environment.apiUrl,
+ *       enableFirebaseIntegration: true,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export function provideValtechAuth(config) {
+    const mergedConfig = {
+        ...DEFAULT_AUTH_CONFIG,
+        ...config,
+    };
+    return makeEnvironmentProviders([
+        { provide: VALTECH_AUTH_CONFIG, useValue: mergedConfig },
+        provideHttpClient(withInterceptors([authInterceptor])),
+        // Inicializar AuthService al arrancar la app
+        {
+            provide: APP_INITIALIZER,
+            useFactory: initializeAuth,
+            deps: [AuthService],
+            multi: true,
+        },
+    ]);
+}
+/**
+ * Provee solo el interceptor (para apps que ya tienen AuthService configurado manualmente).
+ */
+export function provideValtechAuthInterceptor() {
+    return makeEnvironmentProviders([
+        provideHttpClient(withInterceptors([authInterceptor])),
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,135 @@
+import { Injectable, Inject } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { VALTECH_AUTH_CONFIG } from './config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Servicio para gestión de dispositivos del usuario.
+ * Permite listar, aprobar, bloquear y eliminar dispositivos registrados.
+ *
+ * @example
+ * ```typescript
+ * import { DeviceService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class DevicesPage {
+ *   private deviceService = inject(DeviceService);
+ *
+ *   devices = signal<DeviceInfo[]>([]);
+ *
+ *   async ngOnInit() {
+ *     const devices = await firstValueFrom(this.deviceService.listDevices());
+ *     this.devices.set(devices);
+ *   }
+ *
+ *   async blockDevice(deviceId: string) {
+ *     await firstValueFrom(this.deviceService.blockDevice(deviceId));
+ *     // Recargar lista
+ *   }
+ * }
+ * ```
+ */
+export class DeviceService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    get baseUrl() {
+        return `${this.config.apiUrl}/v2/users/me/devices`;
+    }
+    /**
+     * Lista todos los dispositivos registrados del usuario.
+     */
+    listDevices() {
+        return this.http.get(this.baseUrl).pipe(map(response => response.devices));
+    }
+    /**
+     * Obtiene información de un dispositivo específico.
+     */
+    getDevice(deviceId) {
+        return this.http.get(`${this.baseUrl}/${deviceId}`).pipe(map(response => response.device));
+    }
+    /**
+     * Bloquea un dispositivo.
+     * Revoca todas las sesiones activas de ese dispositivo.
+     */
+    blockDevice(deviceId) {
+        return this.http.post(`${this.baseUrl}/${deviceId}/block`, {});
+    }
+    /**
+     * Aprueba un dispositivo pendiente.
+     * Cambia el estado de pending_approval a active.
+     */
+    approveDevice(deviceId) {
+        return this.http.post(`${this.baseUrl}/${deviceId}/approve`, {});
+    }
+    /**
+     * Elimina un dispositivo registrado.
+     */
+    deleteDevice(deviceId) {
+        return this.http.delete(`${this.baseUrl}/${deviceId}`);
+    }
+    /**
+     * Valida un token de acción SIN ejecutarlo.
+     * Útil para mostrar confirmación al usuario antes de ejecutar.
+     * Este endpoint NO requiere autenticación.
+     *
+     * @param token Token JWT de acción
+     * @returns Información del token si es válido
+     *
+     * @example
+     * ```typescript
+     * const token = this.route.snapshot.queryParams['token'];
+     * if (token) {
+     *   const validation = await firstValueFrom(this.deviceService.validateAction(token));
+     *   if (validation.valid) {
+     *     // Mostrar confirmación al usuario
+     *     console.log(`Acción: ${validation.actionType}`);
+     *   }
+     * }
+     * ```
+     */
+    validateAction(token) {
+        return this.http.post(`${this.config.apiUrl}/v2/actions/validate`, { token });
+    }
+    /**
+     * Ejecuta una acción de dispositivo desde un token de email.
+     * Este endpoint NO requiere autenticación.
+     * El token viene en la URL del email de alerta de nuevo inicio de sesión.
+     *
+     * @param token Token JWT de acción (24h, un solo uso)
+     *
+     * @example
+     * ```typescript
+     * // En la página de dispositivos, al detectar ?token=xxx en la URL:
+     * const token = this.route.snapshot.queryParams['token'];
+     * if (token) {
+     *   const result = await firstValueFrom(this.deviceService.executeAction(token));
+     *   if (result.success) {
+     *     console.log(`Dispositivo bloqueado, ${result.sessionsRevoked} sesiones cerradas`);
+     *   }
+     * }
+     * ```
+     */
+    executeAction(token) {
+        // Usa el endpoint unificado de acciones
+        return this.http.post(`${this.config.apiUrl}/v2/actions/execute`, { token }).pipe(map(response => ({
+            operationId: response.operationId,
+            success: response.success,
+            message: response.message,
+            action: response.data?.['action'] || 'refuse',
+            deviceId: response.data?.['deviceId'] || '',
+            sessionsRevoked: response.data?.['sessionsRevoked'],
+        })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DeviceService, deps: [{ token: VALTECH_AUTH_CONFIG }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DeviceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DeviceService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/device.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,EAAE,GAAG,EAAc,MAAM,gBAAgB,CAAC;AAEjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;;;AAW/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,OAAO,aAAa;IACxB,YACuC,MAAyB,EACtD,IAAgB;QADa,WAAM,GAAN,MAAM,CAAmB;QACtD,SAAI,GAAJ,IAAI,CAAY;IACvB,CAAC;IAEJ,IAAY,OAAO;QACjB,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,sBAAsB,CAAC;IACrD,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAsB,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAC1D,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAClC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,QAAgB;QACxB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAClB,GAAG,IAAI,CAAC,OAAO,IAAI,QAAQ,EAAE,CAC9B,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,QAAgB;QAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACnB,GAAG,IAAI,CAAC,OAAO,IAAI,QAAQ,QAAQ,EACnC,EAAE,CACH,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,QAAgB;QAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACnB,GAAG,IAAI,CAAC,OAAO,IAAI,QAAQ,UAAU,EACrC,EAAE,CACH,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,QAAgB;QAC3B,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAqB,GAAG,IAAI,CAAC,OAAO,IAAI,QAAQ,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cAAc,CAAC,KAAa;QAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACnB,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,sBAAsB,EAC3C,EAAE,KAAK,EAAE,CACV,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAAa,CAAC,KAAa;QACzB,wCAAwC;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACnB,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,qBAAqB,EAC1C,EAAE,KAAK,EAAE,CACV,CAAC,IAAI,CACJ,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YACf,WAAW,EAAE,QAAQ,CAAC,WAAW;YACjC,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,MAAM,EAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAY,IAAI,QAAQ;YACzD,QAAQ,EAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,UAAU,CAAY,IAAI,EAAE;YACvD,eAAe,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,iBAAiB,CAAuB;SAC1E,CAAC,CAAC,CACJ,CAAC;IACJ,CAAC;+GAtHU,aAAa,kBAEd,mBAAmB;mHAFlB,aAAa,cADA,MAAM;;4FACnB,aAAa;kBADzB,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;0BAG7B,MAAM;2BAAC,mBAAmB","sourcesContent":["import { Injectable, Inject } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { map, catchError } from 'rxjs/operators';\n\nimport { VALTECH_AUTH_CONFIG } from './config';\nimport {\n  ValtechAuthConfig,\n  DeviceInfo,\n  ListDevicesResponse,\n  DeviceActionResult,\n  DeviceActionRequest,\n  DeviceActionResponse,\n  ValidateActionResponse,\n} from './types';\n\n/**\n * Servicio para gestión de dispositivos del usuario.\n * Permite listar, aprobar, bloquear y eliminar dispositivos registrados.\n *\n * @example\n * ```typescript\n * import { DeviceService } from 'valtech-components';\n *\n * @Component({...})\n * export class DevicesPage {\n *   private deviceService = inject(DeviceService);\n *\n *   devices = signal<DeviceInfo[]>([]);\n *\n *   async ngOnInit() {\n *     const devices = await firstValueFrom(this.deviceService.listDevices());\n *     this.devices.set(devices);\n *   }\n *\n *   async blockDevice(deviceId: string) {\n *     await firstValueFrom(this.deviceService.blockDevice(deviceId));\n *     // Recargar lista\n *   }\n * }\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class DeviceService {\n  constructor(\n    @Inject(VALTECH_AUTH_CONFIG) private config: ValtechAuthConfig,\n    private http: HttpClient\n  ) {}\n\n  private get baseUrl(): string {\n    return `${this.config.apiUrl}/v2/users/me/devices`;\n  }\n\n  /**\n   * Lista todos los dispositivos registrados del usuario.\n   */\n  listDevices(): Observable<DeviceInfo[]> {\n    return this.http.get<ListDevicesResponse>(this.baseUrl).pipe(\n      map(response => response.devices)\n    );\n  }\n\n  /**\n   * Obtiene información de un dispositivo específico.\n   */\n  getDevice(deviceId: string): Observable<DeviceInfo> {\n    return this.http.get<{ operationId: string; device: DeviceInfo }>(\n      `${this.baseUrl}/${deviceId}`\n    ).pipe(map(response => response.device));\n  }\n\n  /**\n   * Bloquea un dispositivo.\n   * Revoca todas las sesiones activas de ese dispositivo.\n   */\n  blockDevice(deviceId: string): Observable<DeviceActionResult> {\n    return this.http.post<DeviceActionResult>(\n      `${this.baseUrl}/${deviceId}/block`,\n      {}\n    );\n  }\n\n  /**\n   * Aprueba un dispositivo pendiente.\n   * Cambia el estado de pending_approval a active.\n   */\n  approveDevice(deviceId: string): Observable<DeviceActionResult> {\n    return this.http.post<DeviceActionResult>(\n      `${this.baseUrl}/${deviceId}/approve`,\n      {}\n    );\n  }\n\n  /**\n   * Elimina un dispositivo registrado.\n   */\n  deleteDevice(deviceId: string): Observable<DeviceActionResult> {\n    return this.http.delete<DeviceActionResult>(`${this.baseUrl}/${deviceId}`);\n  }\n\n  /**\n   * Valida un token de acción SIN ejecutarlo.\n   * Útil para mostrar confirmación al usuario antes de ejecutar.\n   * Este endpoint NO requiere autenticación.\n   *\n   * @param token Token JWT de acción\n   * @returns Información del token si es válido\n   *\n   * @example\n   * ```typescript\n   * const token = this.route.snapshot.queryParams['token'];\n   * if (token) {\n   *   const validation = await firstValueFrom(this.deviceService.validateAction(token));\n   *   if (validation.valid) {\n   *     // Mostrar confirmación al usuario\n   *     console.log(`Acción: ${validation.actionType}`);\n   *   }\n   * }\n   * ```\n   */\n  validateAction(token: string): Observable<ValidateActionResponse> {\n    return this.http.post<ValidateActionResponse>(\n      `${this.config.apiUrl}/v2/actions/validate`,\n      { token }\n    );\n  }\n\n  /**\n   * Ejecuta una acción de dispositivo desde un token de email.\n   * Este endpoint NO requiere autenticación.\n   * El token viene en la URL del email de alerta de nuevo inicio de sesión.\n   *\n   * @param token Token JWT de acción (24h, un solo uso)\n   *\n   * @example\n   * ```typescript\n   * // En la página de dispositivos, al detectar ?token=xxx en la URL:\n   * const token = this.route.snapshot.queryParams['token'];\n   * if (token) {\n   *   const result = await firstValueFrom(this.deviceService.executeAction(token));\n   *   if (result.success) {\n   *     console.log(`Dispositivo bloqueado, ${result.sessionsRevoked} sesiones cerradas`);\n   *   }\n   * }\n   * ```\n   */\n  executeAction(token: string): Observable<DeviceActionResponse> {\n    // Usa el endpoint unificado de acciones\n    return this.http.post<{ operationId: string; success: boolean; message: string; data?: Record<string, unknown> }>(\n      `${this.config.apiUrl}/v2/actions/execute`,\n      { token }\n    ).pipe(\n      map(response => ({\n        operationId: response.operationId,\n        success: response.success,\n        message: response.message,\n        action: (response.data?.['action'] as string) || 'refuse',\n        deviceId: (response.data?.['deviceId'] as string) || '',\n        sessionsRevoked: response.data?.['sessionsRevoked'] as number | undefined,\n      }))\n    );\n  }\n}\n"]}

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

@@ -0,0 +1,194 @@
+import { inject } from '@angular/core';
+import { Router, } from '@angular/router';
+import { AuthService } from './auth.service';
+import { VALTECH_AUTH_CONFIG } from './config';
+/**
+ * Guard que verifica si el usuario está autenticado.
+ * Redirige a loginRoute si no está autenticado.
+ *
+ * @example
+ * ```typescript
+ * import { authGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'dashboard',
+ *     canActivate: [authGuard],
+ *     loadComponent: () => import('./dashboard.page'),
+ *   },
+ * ];
+ * ```
+ */
+export const authGuard = () => {
+    const authService = inject(AuthService);
+    const router = inject(Router);
+    const config = inject(VALTECH_AUTH_CONFIG);
+    if (authService.isAuthenticated()) {
+        return true;
+    }
+    return router.createUrlTree([config.loginRoute]);
+};
+/**
+ * Guard que verifica si el usuario NO está autenticado.
+ * Redirige a homeRoute si ya está autenticado.
+ * Útil para páginas de login/registro.
+ *
+ * @example
+ * ```typescript
+ * import { guestGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'login',
+ *     canActivate: [guestGuard],
+ *     loadComponent: () => import('./login.page'),
+ *   },
+ * ];
+ * ```
+ */
+export const guestGuard = () => {
+    const authService = inject(AuthService);
+    const router = inject(Router);
+    const config = inject(VALTECH_AUTH_CONFIG);
+    if (!authService.isAuthenticated()) {
+        return true;
+    }
+    return router.createUrlTree([config.homeRoute]);
+};
+/**
+ * Factory para crear guard de permisos.
+ * Verifica si el usuario tiene el permiso especificado.
+ *
+ * @param permissions - Permiso o lista de permisos requeridos (OR)
+ * @returns Guard function
+ *
+ * @example
+ * ```typescript
+ * import { authGuard, permissionGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'templates',
+ *     canActivate: [authGuard, permissionGuard('templates:read')],
+ *     loadComponent: () => import('./templates.page'),
+ *   },
+ *   {
+ *     path: 'admin',
+ *     canActivate: [authGuard, permissionGuard(['admin:*', 'super_admin'])],
+ *     loadComponent: () => import('./admin.page'),
+ *   },
+ * ];
+ * ```
+ */
+export function permissionGuard(permissions) {
+    return () => {
+        const authService = inject(AuthService);
+        const router = inject(Router);
+        const config = inject(VALTECH_AUTH_CONFIG);
+        const permArray = Array.isArray(permissions) ? permissions : [permissions];
+        if (authService.hasAnyPermission(permArray)) {
+            return true;
+        }
+        console.warn(`[ValtechAuth] Permiso denegado. Requerido: ${permArray.join(' o ')}`);
+        return router.createUrlTree([config.unauthorizedRoute]);
+    };
+}
+/**
+ * Guard que lee permisos desde route.data.
+ * Permite configurar permisos directamente en la definición de rutas.
+ *
+ * @example
+ * ```typescript
+ * import { authGuard, permissionGuardFromRoute } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'admin/users',
+ *     canActivate: [authGuard, permissionGuardFromRoute],
+ *     data: {
+ *       permissions: ['users:read', 'users:manage'],
+ *       requireAll: false  // true = AND, false = OR (default)
+ *     },
+ *     loadComponent: () => import('./users.page'),
+ *   },
+ * ];
+ * ```
+ */
+export const permissionGuardFromRoute = (route) => {
+    const authService = inject(AuthService);
+    const router = inject(Router);
+    const config = inject(VALTECH_AUTH_CONFIG);
+    const permissions = route.data['permissions'];
+    const requireAll = route.data['requireAll'];
+    if (!permissions || permissions.length === 0) {
+        return true;
+    }
+    const hasAccess = requireAll
+        ? authService.hasAllPermissions(permissions)
+        : authService.hasAnyPermission(permissions);
+    if (hasAccess) {
+        return true;
+    }
+    console.warn(`[ValtechAuth] Permiso denegado. Requerido: ${permissions.join(requireAll ? ' y ' : ' o ')}`);
+    return router.createUrlTree([config.unauthorizedRoute]);
+};
+/**
+ * Guard que verifica si el usuario es super admin.
+ *
+ * @example
+ * ```typescript
+ * import { authGuard, superAdminGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'super-admin',
+ *     canActivate: [authGuard, superAdminGuard],
+ *     loadComponent: () => import('./super-admin.page'),
+ *   },
+ * ];
+ * ```
+ */
+export const superAdminGuard = () => {
+    const authService = inject(AuthService);
+    const router = inject(Router);
+    const config = inject(VALTECH_AUTH_CONFIG);
+    if (authService.isSuperAdmin()) {
+        return true;
+    }
+    console.warn('[ValtechAuth] Acceso de super admin requerido');
+    return router.createUrlTree([config.unauthorizedRoute]);
+};
+/**
+ * Guard que verifica si el usuario tiene un rol específico.
+ *
+ * @param roles - Rol o lista de roles requeridos (OR)
+ * @returns Guard function
+ *
+ * @example
+ * ```typescript
+ * import { authGuard, roleGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   {
+ *     path: 'editor',
+ *     canActivate: [authGuard, roleGuard(['editor', 'admin'])],
+ *     loadComponent: () => import('./editor.page'),
+ *   },
+ * ];
+ * ```
+ */
+export function roleGuard(roles) {
+    return () => {
+        const authService = inject(AuthService);
+        const router = inject(Router);
+        const config = inject(VALTECH_AUTH_CONFIG);
+        const roleArray = Array.isArray(roles) ? roles : [roles];
+        const hasRole = roleArray.some((role) => authService.hasRole(role));
+        if (hasRole) {
+            return true;
+        }
+        console.warn(`[ValtechAuth] Rol requerido: ${roleArray.join(' o ')}`);
+        return router.createUrlTree([config.unauthorizedRoute]);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/guards.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from '@angular/core';\nimport {\n  Router,\n  CanActivateFn,\n  UrlTree,\n  ActivatedRouteSnapshot,\n} from '@angular/router';\nimport { AuthService } from './auth.service';\nimport { VALTECH_AUTH_CONFIG } from './config';\n\n/**\n * Guard que verifica si el usuario está autenticado.\n * Redirige a loginRoute si no está autenticado.\n *\n * @example\n * ```typescript\n * import { authGuard } from 'valtech-components';\n *\n * const routes: Routes = [\n *   {\n *     path: 'dashboard',\n *     canActivate: [authGuard],\n *     loadComponent: () => import('./dashboard.page'),\n *   },\n * ];\n * ```\n */\nexport const authGuard: CanActivateFn = (): boolean | UrlTree => {\n  const authService = inject(AuthService);\n  const router = inject(Router);\n  const config = inject(VALTECH_AUTH_CONFIG);\n\n  if (authService.isAuthenticated()) {\n    return true;\n  }\n\n  return router.createUrlTree([config.loginRoute]);\n};\n\n/**\n * Guard que verifica si el usuario NO está autenticado.\n * Redirige a homeRoute si ya está autenticado.\n * Útil para páginas de login/registro.\n *\n * @example\n * ```typescript\n * import { guestGuard } from 'valtech-components';\n *\n * const routes: Routes = [\n *   {\n *     path: 'login',\n *     canActivate: [guestGuard],\n *     loadComponent: () => import('./login.page'),\n *   },\n * ];\n * ```\n */\nexport const guestGuard: CanActivateFn = (): boolean | UrlTree => {\n  const authService = inject(AuthService);\n  const router = inject(Router);\n  const config = inject(VALTECH_AUTH_CONFIG);\n\n  if (!authService.isAuthenticated()) {\n    return true;\n  }\n\n  return router.createUrlTree([config.homeRoute]);\n};\n\n/**\n * Factory para crear guard de permisos.\n * Verifica si el usuario tiene el permiso especificado.\n *\n * @param permissions - Permiso o lista de permisos requeridos (OR)\n * @returns Guard function\n *\n * @example\n * ```typescript\n * import { authGuard, permissionGuard } from 'valtech-components';\n *\n * const routes: Routes = [\n *   {\n *     path: 'templates',\n *     canActivate: [authGuard, permissionGuard('templates:read')],\n *     loadComponent: () => import('./templates.page'),\n *   },\n *   {\n *     path: 'admin',\n *     canActivate: [authGuard, permissionGuard(['admin:*', 'super_admin'])],\n *     loadComponent: () => import('./admin.page'),\n *   },\n * ];\n * ```\n */\nexport function permissionGuard(\n  permissions: string | string[]\n): CanActivateFn {\n  return (): boolean | UrlTree => {\n    const authService = inject(AuthService);\n    const router = inject(Router);\n    const config = inject(VALTECH_AUTH_CONFIG);\n\n    const permArray = Array.isArray(permissions) ? permissions : [permissions];\n\n    if (authService.hasAnyPermission(permArray)) {\n      return true;\n    }\n\n    console.warn(\n      `[ValtechAuth] Permiso denegado. Requerido: ${permArray.join(' o ')}`\n    );\n    return router.createUrlTree([config.unauthorizedRoute]);\n  };\n}\n\n/**\n * Guard que lee permisos desde route.data.\n * Permite configurar permisos directamente en la definición de rutas.\n *\n * @example\n * ```typescript\n * import { authGuard, permissionGuardFromRoute } from 'valtech-components';\n *\n * const routes: Routes = [\n *   {\n *     path: 'admin/users',\n *     canActivate: [authGuard, permissionGuardFromRoute],\n *     data: {\n *       permissions: ['users:read', 'users:manage'],\n *       requireAll: false  // true = AND, false = OR (default)\n *     },\n *     loadComponent: () => import('./users.page'),\n *   },\n * ];\n * ```\n */\nexport const permissionGuardFromRoute: CanActivateFn = (\n  route: ActivatedRouteSnapshot\n): boolean | UrlTree => {\n  const authService = inject(AuthService);\n  const router = inject(Router);\n  const config = inject(VALTECH_AUTH_CONFIG);\n\n  const permissions = route.data['permissions'] as string[] | undefined;\n  const requireAll = route.data['requireAll'] as boolean | undefined;\n\n  if (!permissions || permissions.length === 0) {\n    return true;\n  }\n\n  const hasAccess = requireAll\n    ? authService.hasAllPermissions(permissions)\n    : authService.hasAnyPermission(permissions);\n\n  if (hasAccess) {\n    return true;\n  }\n\n  console.warn(\n    `[ValtechAuth] Permiso denegado. Requerido: ${permissions.join(\n      requireAll ? ' y ' : ' o '\n    )}`\n  );\n  return router.createUrlTree([config.unauthorizedRoute]);\n};\n\n/**\n * Guard que verifica si el usuario es super admin.\n *\n * @example\n * ```typescript\n * import { authGuard, superAdminGuard } from 'valtech-components';\n *\n * const routes: Routes = [\n *   {\n *     path: 'super-admin',\n *     canActivate: [authGuard, superAdminGuard],\n *     loadComponent: () => import('./super-admin.page'),\n *   },\n * ];\n * ```\n */\nexport const superAdminGuard: CanActivateFn = (): boolean | UrlTree => {\n  const authService = inject(AuthService);\n  const router = inject(Router);\n  const config = inject(VALTECH_AUTH_CONFIG);\n\n  if (authService.isSuperAdmin()) {\n    return true;\n  }\n\n  console.warn('[ValtechAuth] Acceso de super admin requerido');\n  return router.createUrlTree([config.unauthorizedRoute]);\n};\n\n/**\n * Guard que verifica si el usuario tiene un rol específico.\n *\n * @param roles - Rol o lista de roles requeridos (OR)\n * @returns Guard function\n *\n * @example\n * ```typescript\n * import { authGuard, roleGuard } from 'valtech-components';\n *\n * const routes: Routes = [\n *   {\n *     path: 'editor',\n *     canActivate: [authGuard, roleGuard(['editor', 'admin'])],\n *     loadComponent: () => import('./editor.page'),\n *   },\n * ];\n * ```\n */\nexport function roleGuard(roles: string | string[]): CanActivateFn {\n  return (): boolean | UrlTree => {\n    const authService = inject(AuthService);\n    const router = inject(Router);\n    const config = inject(VALTECH_AUTH_CONFIG);\n\n    const roleArray = Array.isArray(roles) ? roles : [roles];\n\n    const hasRole = roleArray.some((role) => authService.hasRole(role));\n\n    if (hasRole) {\n      return true;\n    }\n\n    console.warn(\n      `[ValtechAuth] Rol requerido: ${roleArray.join(' o ')}`\n    );\n    return router.createUrlTree([config.unauthorizedRoute]);\n  };\n}\n"]}

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

@@ -0,0 +1,92 @@
+/**
+ * Valtech Auth Service
+ *
+ * Servicio de autenticación reutilizable para aplicaciones Angular.
+ * Proporciona autenticación con AuthV2, MFA, sincronización entre pestañas,
+ * refresh proactivo de tokens, y registro automático de dispositivos para
+ * push notifications.
+ *
+ * @example
+ * ```typescript
+ * // En main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { provideValtechAuth, provideValtechFirebase } from 'valtech-components';
+ * import { environment } from './environments/environment';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechFirebase(environment.firebase),
+ *     provideValtechAuth({
+ *       apiUrl: environment.apiUrl,
+ *       enableFirebaseIntegration: true,
+ *       enableDeviceRegistration: true, // Auto-registra dispositivos para push
+ *     }),
+ *   ],
+ * });
+ *
+ * // En app.routes.ts
+ * import { authGuard, guestGuard, permissionGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   { path: 'login', canActivate: [guestGuard], loadComponent: () => import('./login.page') },
+ *   { path: 'dashboard', canActivate: [authGuard], loadComponent: () => import('./dashboard.page') },
+ *   { path: 'admin', canActivate: [authGuard, permissionGuard('admin:*')], loadComponent: () => import('./admin.page') },
+ * ];
+ *
+ * // En componentes
+ * import { AuthService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class LoginComponent {
+ *   private auth = inject(AuthService);
+ *
+ *   async login() {
+ *     await firstValueFrom(this.auth.signin({ email, password }));
+ *     if (this.auth.mfaPending().required) {
+ *       // Mostrar UI de MFA
+ *     } else {
+ *       this.router.navigate(['/dashboard']);
+ *     }
+ *   }
+ *
+ *   // Habilitar notificaciones push (solicita permisos + registra dispositivo)
+ *   async enableNotifications() {
+ *     const result = await this.auth.enableNotifications();
+ *     if (result.granted) {
+ *       console.log('Notificaciones habilitadas');
+ *     }
+ *   }
+ *
+ *   // Verificar estado de permisos
+ *   get canReceiveNotifications(): boolean {
+ *     return this.auth.getNotificationPermissionState() === 'granted';
+ *   }
+ *
+ *   // En template: usar signals directamente
+ *   // {{ auth.user()?.email }}
+ *   // @if (auth.hasPermission('templates:edit')) { ... }
+ * }
+ * ```
+ */
+// Tipos
+export * from './types';
+// Configuración
+export { VALTECH_AUTH_CONFIG, provideValtechAuth, provideValtechAuthInterceptor, DEFAULT_AUTH_CONFIG, } from './config';
+// Servicio principal
+export { AuthService } from './auth.service';
+// Guards
+export { authGuard, guestGuard, permissionGuard, permissionGuardFromRoute, superAdminGuard, roleGuard, } from './guards';
+// Interceptor (para uso avanzado)
+export { authInterceptor } from './interceptor';
+// Servicios internos (para testing o extensión)
+export { AuthStateService } from './auth-state.service';
+export { TokenService } from './token.service';
+export { AuthStorageService } from './storage.service';
+export { AuthSyncService } from './sync.service';
+// Servicios de gestión de dispositivos y sesiones
+export { DeviceService } from './device.service';
+export { SessionService } from './session.service';
+// OAuth (Login social)
+export { OAuthService } from './oauth.service';
+export { OAuthCallbackComponent } from './oauth-callback.component';
+//# sourceMappingURL=data:application/json;base64,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