valtech-components 2.0.445 → 2.0.446

package/lib/services/auth/guards.d.ts

@@ -1,123 +0,0 @@
-import { CanActivateFn } from '@angular/router';
-/**
- * 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 declare const authGuard: CanActivateFn;
-/**
- * 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 declare const guestGuard: CanActivateFn;
-/**
- * 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 declare function permissionGuard(permissions: string | string[]): CanActivateFn;
-/**
- * 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 declare const permissionGuardFromRoute: CanActivateFn;
-/**
- * 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 declare const superAdminGuard: CanActivateFn;
-/**
- * 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 declare function roleGuard(roles: string | string[]): CanActivateFn;

package/lib/services/auth/index.d.ts

@@ -1,63 +0,0 @@
-/**
- * Valtech Auth Service
- *
- * Servicio de autenticación reutilizable para aplicaciones Angular.
- * Proporciona autenticación con AuthV2, MFA, sincronización entre pestañas,
- * y refresh proactivo de tokens.
- *
- * @example
- * ```typescript
- * // En 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,
- *     }),
- *   ],
- * });
- *
- * // 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']);
- *     }
- *   }
- *
- *   // En template: usar signals directamente
- *   // {{ auth.user()?.email }}
- *   // @if (auth.hasPermission('templates:edit')) { ... }
- * }
- * ```
- */
-export * from './types';
-export { VALTECH_AUTH_CONFIG, provideValtechAuth, provideValtechAuthInterceptor, DEFAULT_AUTH_CONFIG, } from './config';
-export { AuthService } from './auth.service';
-export { authGuard, guestGuard, permissionGuard, permissionGuardFromRoute, superAdminGuard, roleGuard, } from './guards';
-export { authInterceptor } from './interceptor';
-export { AuthStateService } from './auth-state.service';
-export { TokenService } from './token.service';
-export { AuthStorageService } from './storage.service';
-export { AuthSyncService } from './sync.service';

package/lib/services/auth/interceptor.d.ts

@@ -1,22 +0,0 @@
-import { HttpInterceptorFn } from '@angular/common/http';
-/**
- * Interceptor HTTP que:
- * 1. Agrega header Authorization con Bearer token a requests API
- * 2. Maneja errores 401 refrescando el token automáticamente
- * 3. Encola requests durante el refresco para evitar múltiples refresh
- *
- * @example
- * ```typescript
- * // Incluido automáticamente por provideValtechAuth()
- * // Para uso manual:
- * import { provideHttpClient, withInterceptors } from '@angular/common/http';
- * import { authInterceptor } from 'valtech-components';
- *
- * bootstrapApplication(AppComponent, {
- *   providers: [
- *     provideHttpClient(withInterceptors([authInterceptor])),
- *   ],
- * });
- * ```
- */
-export declare const authInterceptor: HttpInterceptorFn;

package/lib/services/auth/storage.service.d.ts

@@ -1,48 +0,0 @@
-import { StoredAuthState, GetPermissionsResponse } from './types';
-import * as i0 from "@angular/core";
-/**
- * Servicio para persistencia de estado de autenticación en localStorage.
- */
-export declare class AuthStorageService {
-    private config;
-    private keys;
-    constructor();
-    /**
-     * Guarda el estado completo de autenticación.
-     */
-    saveState(state: StoredAuthState): void;
-    /**
-     * Carga el estado de autenticación desde storage.
-     */
-    loadState(): Partial<StoredAuthState>;
-    /**
-     * Guarda solo el access token.
-     */
-    saveAccessToken(token: string, expiresAt?: number): void;
-    /**
-     * Guarda los permisos actualizados.
-     */
-    savePermissions(response: GetPermissionsResponse): void;
-    /**
-     * Carga los permisos desde storage.
-     */
-    loadPermissions(): {
-        roles: string[];
-        permissions: string[];
-        isSuperAdmin: boolean;
-    };
-    /**
-     * Obtiene el refresh token.
-     */
-    getRefreshToken(): string | null;
-    /**
-     * Limpia todo el estado de autenticación.
-     */
-    clear(): void;
-    /**
-     * Verifica si hay estado guardado.
-     */
-    hasStoredState(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AuthStorageService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AuthStorageService>;
-}

package/lib/services/auth/sync.service.d.ts

@@ -1,49 +0,0 @@
-import { OnDestroy } from '@angular/core';
-import { Observable } from 'rxjs';
-import { AuthSyncEvent } from './types';
-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 declare class AuthSyncService implements OnDestroy {
-    private config;
-    private channel;
-    private channelName;
-    private eventSubject;
-    private storageListener;
-    /** Observable de eventos de sincronización */
-    readonly onEvent$: Observable<AuthSyncEvent>;
-    constructor();
-    /**
-     * Inicia la sincronización entre pestañas.
-     */
-    start(): void;
-    /**
-     * Detiene la sincronización.
-     */
-    stop(): void;
-    /**
-     * Envía un evento a otras pestañas.
-     */
-    broadcast(event: Omit<AuthSyncEvent, 'timestamp'>): void;
-    ngOnDestroy(): void;
-    /**
-     * Inicializa BroadcastChannel API.
-     */
-    private initBroadcastChannel;
-    /**
-     * Inicializa fallback con storage events.
-     */
-    private initStorageEvents;
-    /**
-     * Envía evento via localStorage (fallback).
-     */
-    private broadcastViaStorage;
-    /**
-     * Maneja un evento recibido.
-     */
-    private handleEvent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AuthSyncService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AuthSyncService>;
-}

package/lib/services/auth/token.service.d.ts

@@ -1,51 +0,0 @@
-import { JWTClaims } from './types';
-import * as i0 from "@angular/core";
-/**
- * Servicio para manejo de tokens JWT.
- * Parseo y validación de tokens sin dependencias externas.
- */
-export declare 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: string): JWTClaims | null;
-    /**
-     * Verifica si un token es válido (no expirado).
-     * @param token - Token JWT
-     * @returns true si el token es válido
-     */
-    isTokenValid(token: string): boolean;
-    /**
-     * Obtiene el tiempo restante del token en segundos.
-     * @param token - Token JWT
-     * @returns Segundos restantes o 0 si expirado
-     */
-    getTimeToExpiry(token: string): number;
-    /**
-     * Obtiene el timestamp de expiración del token.
-     * @param token - Token JWT
-     * @returns Timestamp en milisegundos o null
-     */
-    getExpirationTime(token: string): number | null;
-    /**
-     * Extrae el user ID del token.
-     * @param token - Token JWT
-     * @returns User ID o null
-     */
-    getUserId(token: string): string | null;
-    /**
-     * Extrae el email del token.
-     * @param token - Token JWT
-     * @returns Email o null
-     */
-    getEmail(token: string): string | null;
-    /**
-     * Decodifica base64url a string.
-     * Base64url usa - y _ en lugar de + y /
-     */
-    private base64UrlDecode;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TokenService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TokenService>;
-}

package/lib/services/auth/types.d.ts

@@ -1,315 +0,0 @@
-/**
- * Tipos e interfaces para el servicio de autenticación de Valtech.
- * Alineados con el backend AuthV2.
- */
-/**
- * Configuración para el servicio de autenticación.
- */
-export interface ValtechAuthConfig {
-    /** URL base de la API (ej: 'https://api.myvaltech.com') */
-    apiUrl: string;
-    /** Prefijo para endpoints de auth (default: '/v2/auth') */
-    authPrefix?: string;
-    /** Prefijo para las claves de localStorage (default: 'valtech_auth_') */
-    storagePrefix?: string;
-    /** Tiempo antes de expiración para refrescar token en segundos (default: 60) */
-    refreshBeforeExpiry?: number;
-    /** Habilitar sincronización entre pestañas (default: true) */
-    enableTabSync?: boolean;
-    /** Ruta de redirección cuando no autenticado (default: '/login') */
-    loginRoute?: string;
-    /** Ruta de redirección cuando ya autenticado (default: '/') */
-    homeRoute?: string;
-    /** Ruta para acceso denegado (default: '/unauthorized') */
-    unauthorizedRoute?: string;
-    /** Habilitar integración con FirebaseService (default: false) */
-    enableFirebaseIntegration?: boolean;
-}
-/**
- * Estado completo de autenticación.
- */
-export interface AuthState {
-    /** Usuario está autenticado */
-    isAuthenticated: boolean;
-    /** Estado de carga inicial */
-    isLoading: boolean;
-    /** Token de acceso actual */
-    accessToken: string | null;
-    /** Token de refresco actual */
-    refreshToken: string | null;
-    /** ID del usuario */
-    userId: string | null;
-    /** Email del usuario */
-    email: string | null;
-    /** Roles del usuario */
-    roles: string[];
-    /** Permisos del usuario (formato 'resource:action') */
-    permissions: string[];
-    /** Usuario es super admin */
-    isSuperAdmin: boolean;
-    /** Timestamp de expiración del accessToken (ms) */
-    expiresAt: number | null;
-    /** Error de autenticación (si existe) */
-    error: AuthError | null;
-}
-/**
- * Información del usuario autenticado.
- */
-export interface AuthUser {
-    userId: string;
-    email: string;
-    name?: string;
-    roles: string[];
-    permissions: string[];
-    isSuperAdmin: boolean;
-}
-/**
- * Error de autenticación.
- */
-export interface AuthError {
-    code: string;
-    message: string;
-}
-/**
- * Estado inicial de autenticación.
- */
-export declare const INITIAL_AUTH_STATE: AuthState;
-/** Métodos de MFA soportados */
-export type MFAMethod = 'EMAIL' | 'SMS';
-/**
- * Estado de MFA pendiente.
- */
-export interface MFAPendingState {
-    required: boolean;
-    mfaToken: string | null;
-    method: MFAMethod | null;
-}
-/**
- * Estado inicial de MFA.
- */
-export declare const INITIAL_MFA_STATE: MFAPendingState;
-/**
- * Resultado de setup de MFA.
- */
-export interface MFASetupResult {
-    codeSent: boolean;
-    message: string;
-}
-/**
- * Estado de MFA del usuario.
- */
-export interface MFAStatus {
-    enabled: boolean;
-    method: MFAMethod | null;
-}
-/**
- * Request para signup (registro).
- */
-export interface SignupRequest {
-    email: string;
-    password: string;
-    name: string;
-    phone?: string;
-}
-/**
- * Response de signup (registro).
- */
-export interface SignupResponse {
-    operationId: string;
-    userId: string;
-    message: string;
-}
-/**
- * Request para verificar email.
- */
-export interface VerifyEmailRequest {
-    email: string;
-    code: string;
-}
-/**
- * Response de verificación de email.
- * Si es exitoso, incluye tokens para auto-login.
- */
-export interface VerifyEmailResponse {
-    operationId: string;
-    verified: boolean;
-    accessToken?: string;
-    refreshToken?: string;
-    firebaseToken?: string;
-    expiresIn?: number;
-    tokenType?: string;
-}
-/**
- * Request para reenviar código de verificación.
- */
-export interface ResendCodeRequest {
-    email: string;
-    type: 'EMAIL_VERIFY' | 'PASSWORD_RESET';
-}
-/**
- * Response de reenvío de código.
- */
-export interface ResendCodeResponse {
-    operationId: string;
-    sent: boolean;
-}
-/**
- * Request para signin.
- */
-export interface SigninRequest {
-    email: string;
-    password: string;
-}
-/**
- * Response de signin.
- */
-export interface SigninResponse {
-    operationId: string;
-    accessToken?: string;
-    refreshToken?: string;
-    firebaseToken?: string;
-    expiresIn?: number;
-    tokenType?: string;
-    mfaRequired?: boolean;
-    mfaToken?: string;
-    mfaMethod?: MFAMethod;
-    roles?: string[];
-    permissions?: string[];
-}
-/**
- * Request para verificar MFA.
- */
-export interface MFAVerifyRequest {
-    mfaToken: string;
-    code: string;
-}
-/**
- * Response de verificar MFA.
- */
-export interface MFAVerifyResponse {
-    operationId: string;
-    accessToken: string;
-    refreshToken: string;
-    firebaseToken?: string;
-    expiresIn: number;
-    tokenType: string;
-    roles?: string[];
-    permissions?: string[];
-}
-/**
- * Request para refrescar token.
- */
-export interface RefreshRequest {
-    refreshToken: string;
-}
-/**
- * Response de refrescar token.
- */
-export interface RefreshResponse {
-    operationId: string;
-    accessToken: string;
-    expiresIn: number;
-}
-/**
- * Request para logout.
- */
-export interface LogoutRequest {
-    refreshToken: string;
-}
-/**
- * Response de logout.
- */
-export interface LogoutResponse {
-    operationId: string;
-    success: boolean;
-}
-/**
- * Response de obtener permisos.
- */
-export interface GetPermissionsResponse {
-    operationId: string;
-    roles: string[];
-    permissions: string[];
-    isSuperAdmin: boolean;
-}
-/**
- * Request para setup de MFA.
- */
-export interface MFASetupRequest {
-    method: MFAMethod;
-    phone?: string;
-}
-/**
- * Response de setup de MFA.
- */
-export interface MFASetupResponse {
-    operationId: string;
-    codeSent: boolean;
-    message: string;
-}
-/**
- * Request para confirmar MFA.
- */
-export interface MFAConfirmRequest {
-    code: string;
-}
-/**
- * Response de confirmar MFA.
- */
-export interface MFAConfirmResponse {
-    operationId: string;
-    mfaEnabled: boolean;
-    method: MFAMethod;
-}
-/**
- * Request para deshabilitar MFA.
- */
-export interface MFADisableRequest {
-    password: string;
-}
-/**
- * Response de deshabilitar MFA.
- */
-export interface MFADisableResponse {
-    operationId: string;
-    mfaDisabled: boolean;
-}
-/** Tipos de eventos de sincronización entre pestañas */
-export type AuthSyncEventType = 'LOGIN' | 'LOGOUT' | 'TOKEN_REFRESH' | 'PERMISSIONS_UPDATE';
-/**
- * Evento de sincronización entre pestañas.
- */
-export interface AuthSyncEvent {
-    type: AuthSyncEventType;
-    timestamp: number;
-    payload?: {
-        accessToken?: string;
-        expiresAt?: number;
-    };
-}
-/**
- * Claims del JWT de acceso.
- */
-export interface JWTClaims {
-    /** User ID */
-    uid: string;
-    /** Email */
-    email: string;
-    /** Session ID */
-    sid?: string;
-    /** Issued at */
-    iat: number;
-    /** Expiration */
-    exp: number;
-}
-/**
- * Datos persistidos en storage.
- */
-export interface StoredAuthState {
-    accessToken: string;
-    refreshToken: string;
-    roles: string[];
-    permissions: string[];
-    isSuperAdmin: boolean;
-    expiresAt?: number;
-}