valtech-components 2.0.428 → 2.0.430

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,70 @@
+/**
+ * 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')) { ... }
+ * }
+ * ```
+ */
+// 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';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,98 @@
+import { inject } from '@angular/core';
+import { throwError, BehaviorSubject } from 'rxjs';
+import { catchError, filter, take, switchMap, finalize } from 'rxjs/operators';
+import { AuthService } from './auth.service';
+import { VALTECH_AUTH_CONFIG } from './config';
+// Control de estado de refresco (singleton a nivel de módulo)
+let isRefreshing = false;
+const refreshTokenSubject = new BehaviorSubject(null);
+/**
+ * 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 const authInterceptor = (request, next) => {
+    const authService = inject(AuthService);
+    const config = inject(VALTECH_AUTH_CONFIG);
+    // Omitir requests que no son a nuestra API
+    if (!isApiRequest(request, config.apiUrl)) {
+        return next(request);
+    }
+    // Omitir endpoints de auth que no necesitan token
+    if (isAuthEndpoint(request, config.authPrefix)) {
+        return next(request);
+    }
+    const accessToken = authService.accessToken();
+    // Agregar header de autorización si hay token
+    if (accessToken) {
+        request = addAuthHeader(request, accessToken);
+    }
+    return next(request).pipe(catchError((error) => {
+        if (error.status === 401 && !isAuthEndpoint(request, config.authPrefix)) {
+            return handle401Error(request, next, authService);
+        }
+        if (error.status === 403) {
+            console.error('[ValtechAuth] Permiso denegado:', error.error?.message || 'Acceso prohibido');
+        }
+        return throwError(() => error);
+    }));
+};
+/**
+ * Agrega header de autorización a la request.
+ */
+function addAuthHeader(request, token) {
+    return request.clone({
+        setHeaders: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+}
+/**
+ * Verifica si la request es a nuestra API.
+ */
+function isApiRequest(request, apiUrl) {
+    return request.url.startsWith(apiUrl) || request.url.includes('/v2/auth');
+}
+/**
+ * Verifica si la request es a un endpoint de auth que no debe reintentar.
+ */
+function isAuthEndpoint(request, authPrefix) {
+    const authEndpoints = ['/signin', '/signup', '/refresh', '/logout', '/mfa/verify'];
+    return authEndpoints.some((endpoint) => request.url.includes(`${authPrefix}${endpoint}`));
+}
+/**
+ * Maneja errores 401 refrescando el token.
+ */
+function handle401Error(request, next, authService) {
+    if (!isRefreshing) {
+        isRefreshing = true;
+        refreshTokenSubject.next(null);
+        return authService.refreshAccessToken().pipe(switchMap((response) => {
+            refreshTokenSubject.next(response.accessToken);
+            return next(addAuthHeader(request, response.accessToken));
+        }), catchError((error) => {
+            authService.logout();
+            return throwError(() => error);
+        }), finalize(() => {
+            isRefreshing = false;
+        }));
+    }
+    // Esperar a que termine el refresco en curso
+    return refreshTokenSubject.pipe(filter((token) => token !== null), take(1), switchMap((token) => next(addAuthHeader(request, token))));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAQvC,OAAO,EAAc,UAAU,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C,8DAA8D;AAC9D,IAAI,YAAY,GAAG,KAAK,CAAC;AACzB,MAAM,mBAAmB,GAAG,IAAI,eAAe,CAAgB,IAAI,CAAC,CAAC;AAErE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAsB,CAChD,OAA6B,EAC7B,IAAmB,EACa,EAAE;IAClC,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;IAE3C,2CAA2C;IAC3C,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1C,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IAED,kDAAkD;IAClD,IAAI,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,UAAW,CAAC,EAAE,CAAC;QAChD,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IAED,MAAM,WAAW,GAAG,WAAW,CAAC,WAAW,EAAE,CAAC;IAE9C,8CAA8C;IAC9C,IAAI,WAAW,EAAE,CAAC;QAChB,OAAO,GAAG,aAAa,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CACvB,UAAU,CAAC,CAAC,KAAwB,EAAE,EAAE;QACtC,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,UAAW,CAAC,EAAE,CAAC;YACzE,OAAO,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;QACpD,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;YACzB,OAAO,CAAC,KAAK,CACX,iCAAiC,EACjC,KAAK,CAAC,KAAK,EAAE,OAAO,IAAI,kBAAkB,CAC3C,CAAC;QACJ,CAAC;QAED,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC,CAAC,CACH,CAAC;AACJ,CAAC,CAAC;AAEF;;GAEG;AACH,SAAS,aAAa,CACpB,OAA6B,EAC7B,KAAa;IAEb,OAAO,OAAO,CAAC,KAAK,CAAC;QACnB,UAAU,EAAE;YACV,aAAa,EAAE,UAAU,KAAK,EAAE;SACjC;KACF,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CAAC,OAA6B,EAAE,MAAc;IACjE,OAAO,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAC5E,CAAC;AAED;;GAEG;AACH,SAAS,cAAc,CACrB,OAA6B,EAC7B,UAAkB;IAElB,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC;IACnF,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CACrC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,UAAU,GAAG,QAAQ,EAAE,CAAC,CACjD,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,cAAc,CACrB,OAA6B,EAC7B,IAAmB,EACnB,WAAwB;IAExB,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,YAAY,GAAG,IAAI,CAAC;QACpB,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE/B,OAAO,WAAW,CAAC,kBAAkB,EAAE,CAAC,IAAI,CAC1C,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE;YACrB,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YAC/C,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;QAC5D,CAAC,CAAC,EACF,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,WAAW,CAAC,MAAM,EAAE,CAAC;YACrB,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,EACF,QAAQ,CAAC,GAAG,EAAE;YACZ,YAAY,GAAG,KAAK,CAAC;QACvB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,6CAA6C;IAC7C,OAAO,mBAAmB,CAAC,IAAI,CAC7B,MAAM,CAAC,CAAC,KAAK,EAAmB,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,EAClD,IAAI,CAAC,CAAC,CAAC,EACP,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAC1D,CAAC;AACJ,CAAC","sourcesContent":["import { inject } from '@angular/core';\nimport {\n  HttpInterceptorFn,\n  HttpRequest,\n  HttpHandlerFn,\n  HttpEvent,\n  HttpErrorResponse,\n} from '@angular/common/http';\nimport { Observable, throwError, BehaviorSubject } from 'rxjs';\nimport { catchError, filter, take, switchMap, finalize } from 'rxjs/operators';\nimport { AuthService } from './auth.service';\nimport { VALTECH_AUTH_CONFIG } from './config';\n\n// Control de estado de refresco (singleton a nivel de módulo)\nlet isRefreshing = false;\nconst refreshTokenSubject = new BehaviorSubject<string | null>(null);\n\n/**\n * Interceptor HTTP que:\n * 1. Agrega header Authorization con Bearer token a requests API\n * 2. Maneja errores 401 refrescando el token automáticamente\n * 3. Encola requests durante el refresco para evitar múltiples refresh\n *\n * @example\n * ```typescript\n * // Incluido automáticamente por provideValtechAuth()\n * // Para uso manual:\n * import { provideHttpClient, withInterceptors } from '@angular/common/http';\n * import { authInterceptor } from 'valtech-components';\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     provideHttpClient(withInterceptors([authInterceptor])),\n *   ],\n * });\n * ```\n */\nexport const authInterceptor: HttpInterceptorFn = (\n  request: HttpRequest<unknown>,\n  next: HttpHandlerFn\n): Observable<HttpEvent<unknown>> => {\n  const authService = inject(AuthService);\n  const config = inject(VALTECH_AUTH_CONFIG);\n\n  // Omitir requests que no son a nuestra API\n  if (!isApiRequest(request, config.apiUrl)) {\n    return next(request);\n  }\n\n  // Omitir endpoints de auth que no necesitan token\n  if (isAuthEndpoint(request, config.authPrefix!)) {\n    return next(request);\n  }\n\n  const accessToken = authService.accessToken();\n\n  // Agregar header de autorización si hay token\n  if (accessToken) {\n    request = addAuthHeader(request, accessToken);\n  }\n\n  return next(request).pipe(\n    catchError((error: HttpErrorResponse) => {\n      if (error.status === 401 && !isAuthEndpoint(request, config.authPrefix!)) {\n        return handle401Error(request, next, authService);\n      }\n\n      if (error.status === 403) {\n        console.error(\n          '[ValtechAuth] Permiso denegado:',\n          error.error?.message || 'Acceso prohibido'\n        );\n      }\n\n      return throwError(() => error);\n    })\n  );\n};\n\n/**\n * Agrega header de autorización a la request.\n */\nfunction addAuthHeader(\n  request: HttpRequest<unknown>,\n  token: string\n): HttpRequest<unknown> {\n  return request.clone({\n    setHeaders: {\n      Authorization: `Bearer ${token}`,\n    },\n  });\n}\n\n/**\n * Verifica si la request es a nuestra API.\n */\nfunction isApiRequest(request: HttpRequest<unknown>, apiUrl: string): boolean {\n  return request.url.startsWith(apiUrl) || request.url.includes('/v2/auth');\n}\n\n/**\n * Verifica si la request es a un endpoint de auth que no debe reintentar.\n */\nfunction isAuthEndpoint(\n  request: HttpRequest<unknown>,\n  authPrefix: string\n): boolean {\n  const authEndpoints = ['/signin', '/signup', '/refresh', '/logout', '/mfa/verify'];\n  return authEndpoints.some((endpoint) =>\n    request.url.includes(`${authPrefix}${endpoint}`)\n  );\n}\n\n/**\n * Maneja errores 401 refrescando el token.\n */\nfunction handle401Error(\n  request: HttpRequest<unknown>,\n  next: HttpHandlerFn,\n  authService: AuthService\n): Observable<HttpEvent<unknown>> {\n  if (!isRefreshing) {\n    isRefreshing = true;\n    refreshTokenSubject.next(null);\n\n    return authService.refreshAccessToken().pipe(\n      switchMap((response) => {\n        refreshTokenSubject.next(response.accessToken);\n        return next(addAuthHeader(request, response.accessToken));\n      }),\n      catchError((error) => {\n        authService.logout();\n        return throwError(() => error);\n      }),\n      finalize(() => {\n        isRefreshing = false;\n      })\n    );\n  }\n\n  // Esperar a que termine el refresco en curso\n  return refreshTokenSubject.pipe(\n    filter((token): token is string => token !== null),\n    take(1),\n    switchMap((token) => next(addAuthHeader(request, token)))\n  );\n}\n"]}

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

@@ -0,0 +1,138 @@
+import { Injectable, inject } from '@angular/core';
+import { VALTECH_AUTH_CONFIG } from './config';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para persistencia de estado de autenticación en localStorage.
+ */
+export class AuthStorageService {
+    constructor() {
+        this.config = inject(VALTECH_AUTH_CONFIG);
+        const prefix = this.config.storagePrefix || 'valtech_auth_';
+        this.keys = {
+            ACCESS_TOKEN: `${prefix}access_token`,
+            REFRESH_TOKEN: `${prefix}refresh_token`,
+            ROLES: `${prefix}roles`,
+            PERMISSIONS: `${prefix}permissions`,
+            IS_SUPER_ADMIN: `${prefix}is_super_admin`,
+            EXPIRES_AT: `${prefix}expires_at`,
+        };
+    }
+    /**
+     * Guarda el estado completo de autenticación.
+     */
+    saveState(state) {
+        try {
+            localStorage.setItem(this.keys.ACCESS_TOKEN, state.accessToken);
+            localStorage.setItem(this.keys.REFRESH_TOKEN, state.refreshToken);
+            localStorage.setItem(this.keys.ROLES, JSON.stringify(state.roles));
+            localStorage.setItem(this.keys.PERMISSIONS, JSON.stringify(state.permissions));
+            localStorage.setItem(this.keys.IS_SUPER_ADMIN, String(state.isSuperAdmin));
+            if (state.expiresAt) {
+                localStorage.setItem(this.keys.EXPIRES_AT, String(state.expiresAt));
+            }
+        }
+        catch (e) {
+            console.warn('[ValtechAuth] Error guardando estado en storage:', e);
+        }
+    }
+    /**
+     * Carga el estado de autenticación desde storage.
+     */
+    loadState() {
+        try {
+            const accessToken = localStorage.getItem(this.keys.ACCESS_TOKEN);
+            const refreshToken = localStorage.getItem(this.keys.REFRESH_TOKEN);
+            const rolesJson = localStorage.getItem(this.keys.ROLES);
+            const permissionsJson = localStorage.getItem(this.keys.PERMISSIONS);
+            const isSuperAdmin = localStorage.getItem(this.keys.IS_SUPER_ADMIN) === 'true';
+            const expiresAtStr = localStorage.getItem(this.keys.EXPIRES_AT);
+            return {
+                accessToken: accessToken || undefined,
+                refreshToken: refreshToken || undefined,
+                roles: rolesJson ? JSON.parse(rolesJson) : [],
+                permissions: permissionsJson ? JSON.parse(permissionsJson) : [],
+                isSuperAdmin,
+                expiresAt: expiresAtStr ? Number(expiresAtStr) : undefined,
+            };
+        }
+        catch (e) {
+            console.warn('[ValtechAuth] Error cargando estado desde storage:', e);
+            return {};
+        }
+    }
+    /**
+     * Guarda solo el access token.
+     */
+    saveAccessToken(token, expiresAt) {
+        try {
+            localStorage.setItem(this.keys.ACCESS_TOKEN, token);
+            if (expiresAt) {
+                localStorage.setItem(this.keys.EXPIRES_AT, String(expiresAt));
+            }
+        }
+        catch (e) {
+            console.warn('[ValtechAuth] Error guardando access token:', e);
+        }
+    }
+    /**
+     * Guarda los permisos actualizados.
+     */
+    savePermissions(response) {
+        try {
+            localStorage.setItem(this.keys.ROLES, JSON.stringify(response.roles));
+            localStorage.setItem(this.keys.PERMISSIONS, JSON.stringify(response.permissions));
+            localStorage.setItem(this.keys.IS_SUPER_ADMIN, String(response.isSuperAdmin));
+        }
+        catch (e) {
+            console.warn('[ValtechAuth] Error guardando permisos:', e);
+        }
+    }
+    /**
+     * Carga los permisos desde storage.
+     */
+    loadPermissions() {
+        try {
+            const rolesJson = localStorage.getItem(this.keys.ROLES);
+            const permissionsJson = localStorage.getItem(this.keys.PERMISSIONS);
+            const isSuperAdmin = localStorage.getItem(this.keys.IS_SUPER_ADMIN) === 'true';
+            return {
+                roles: rolesJson ? JSON.parse(rolesJson) : [],
+                permissions: permissionsJson ? JSON.parse(permissionsJson) : [],
+                isSuperAdmin,
+            };
+        }
+        catch {
+            return { roles: [], permissions: [], isSuperAdmin: false };
+        }
+    }
+    /**
+     * Obtiene el refresh token.
+     */
+    getRefreshToken() {
+        return localStorage.getItem(this.keys.REFRESH_TOKEN);
+    }
+    /**
+     * Limpia todo el estado de autenticación.
+     */
+    clear() {
+        try {
+            Object.values(this.keys).forEach((key) => localStorage.removeItem(key));
+        }
+        catch (e) {
+            console.warn('[ValtechAuth] Error limpiando storage:', e);
+        }
+    }
+    /**
+     * Verifica si hay estado guardado.
+     */
+    hasStoredState() {
+        return !!localStorage.getItem(this.keys.ACCESS_TOKEN);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/storage.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;;AAe/C;;GAEG;AAEH,MAAM,OAAO,kBAAkB;IAI7B;QAHQ,WAAM,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;QAI3C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,eAAe,CAAC;QAC5D,IAAI,CAAC,IAAI,GAAG;YACV,YAAY,EAAE,GAAG,MAAM,cAAc;YACrC,aAAa,EAAE,GAAG,MAAM,eAAe;YACvC,KAAK,EAAE,GAAG,MAAM,OAAO;YACvB,WAAW,EAAE,GAAG,MAAM,aAAa;YACnC,cAAc,EAAE,GAAG,MAAM,gBAAgB;YACzC,UAAU,EAAE,GAAG,MAAM,YAAY;SAClC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAAsB;QAC9B,IAAI,CAAC;YACH,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;YAChE,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;YAClE,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;YACnE,YAAY,CAAC,OAAO,CAClB,IAAI,CAAC,IAAI,CAAC,WAAW,EACrB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,WAAW,CAAC,CAClC,CAAC;YACF,YAAY,CAAC,OAAO,CAClB,IAAI,CAAC,IAAI,CAAC,cAAc,EACxB,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAC3B,CAAC;YACF,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;gBACpB,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;YACtE,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,kDAAkD,EAAE,CAAC,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;IAED;;OAEG;IACH,SAAS;QACP,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACjE,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACnE,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxD,MAAM,eAAe,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACpE,MAAM,YAAY,GAChB,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,MAAM,CAAC;YAC5D,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAEhE,OAAO;gBACL,WAAW,EAAE,WAAW,IAAI,SAAS;gBACrC,YAAY,EAAE,YAAY,IAAI,SAAS;gBACvC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE;gBAC7C,WAAW,EAAE,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE;gBAC/D,YAAY;gBACZ,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS;aAC3D,CAAC;QACJ,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,oDAAoD,EAAE,CAAC,CAAC,CAAC;YACtE,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,eAAe,CAAC,KAAa,EAAE,SAAkB;QAC/C,IAAI,CAAC;YACH,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;YACpD,IAAI,SAAS,EAAE,CAAC;gBACd,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;YAChE,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,6CAA6C,EAAE,CAAC,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;IAED;;OAEG;IACH,eAAe,CAAC,QAAgC;QAC9C,IAAI,CAAC;YACH,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;YACtE,YAAY,CAAC,OAAO,CAClB,IAAI,CAAC,IAAI,CAAC,WAAW,EACrB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,CACrC,CAAC;YACF,YAAY,CAAC,OAAO,CAClB,IAAI,CAAC,IAAI,CAAC,cAAc,EACxB,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,CAC9B,CAAC;QACJ,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,yCAAyC,EAAE,CAAC,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IAED;;OAEG;IACH,eAAe;QAKb,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxD,MAAM,eAAe,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACpE,MAAM,YAAY,GAChB,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,MAAM,CAAC;YAE5D,OAAO;gBACL,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE;gBAC7C,WAAW,EAAE,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE;gBAC/D,YAAY;aACb,CAAC;QACJ,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;QAC7D,CAAC;IACH,CAAC;IAED;;OAEG;IACH,eAAe;QACb,OAAO,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACvD,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC;YACH,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1E,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,wCAAwC,EAAE,CAAC,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IACxD,CAAC;+GAnJU,kBAAkB;mHAAlB,kBAAkB,cADL,MAAM;;4FACnB,kBAAkB;kBAD9B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { VALTECH_AUTH_CONFIG } from './config';\nimport { StoredAuthState, GetPermissionsResponse } from './types';\n\n/**\n * Claves de storage para autenticación.\n */\ninterface StorageKeys {\n  ACCESS_TOKEN: string;\n  REFRESH_TOKEN: string;\n  ROLES: string;\n  PERMISSIONS: string;\n  IS_SUPER_ADMIN: string;\n  EXPIRES_AT: string;\n}\n\n/**\n * Servicio para persistencia de estado de autenticación en localStorage.\n */\n@Injectable({ providedIn: 'root' })\nexport class AuthStorageService {\n  private config = inject(VALTECH_AUTH_CONFIG);\n  private keys: StorageKeys;\n\n  constructor() {\n    const prefix = this.config.storagePrefix || 'valtech_auth_';\n    this.keys = {\n      ACCESS_TOKEN: `${prefix}access_token`,\n      REFRESH_TOKEN: `${prefix}refresh_token`,\n      ROLES: `${prefix}roles`,\n      PERMISSIONS: `${prefix}permissions`,\n      IS_SUPER_ADMIN: `${prefix}is_super_admin`,\n      EXPIRES_AT: `${prefix}expires_at`,\n    };\n  }\n\n  /**\n   * Guarda el estado completo de autenticación.\n   */\n  saveState(state: StoredAuthState): void {\n    try {\n      localStorage.setItem(this.keys.ACCESS_TOKEN, state.accessToken);\n      localStorage.setItem(this.keys.REFRESH_TOKEN, state.refreshToken);\n      localStorage.setItem(this.keys.ROLES, JSON.stringify(state.roles));\n      localStorage.setItem(\n        this.keys.PERMISSIONS,\n        JSON.stringify(state.permissions)\n      );\n      localStorage.setItem(\n        this.keys.IS_SUPER_ADMIN,\n        String(state.isSuperAdmin)\n      );\n      if (state.expiresAt) {\n        localStorage.setItem(this.keys.EXPIRES_AT, String(state.expiresAt));\n      }\n    } catch (e) {\n      console.warn('[ValtechAuth] Error guardando estado en storage:', e);\n    }\n  }\n\n  /**\n   * Carga el estado de autenticación desde storage.\n   */\n  loadState(): Partial<StoredAuthState> {\n    try {\n      const accessToken = localStorage.getItem(this.keys.ACCESS_TOKEN);\n      const refreshToken = localStorage.getItem(this.keys.REFRESH_TOKEN);\n      const rolesJson = localStorage.getItem(this.keys.ROLES);\n      const permissionsJson = localStorage.getItem(this.keys.PERMISSIONS);\n      const isSuperAdmin =\n        localStorage.getItem(this.keys.IS_SUPER_ADMIN) === 'true';\n      const expiresAtStr = localStorage.getItem(this.keys.EXPIRES_AT);\n\n      return {\n        accessToken: accessToken || undefined,\n        refreshToken: refreshToken || undefined,\n        roles: rolesJson ? JSON.parse(rolesJson) : [],\n        permissions: permissionsJson ? JSON.parse(permissionsJson) : [],\n        isSuperAdmin,\n        expiresAt: expiresAtStr ? Number(expiresAtStr) : undefined,\n      };\n    } catch (e) {\n      console.warn('[ValtechAuth] Error cargando estado desde storage:', e);\n      return {};\n    }\n  }\n\n  /**\n   * Guarda solo el access token.\n   */\n  saveAccessToken(token: string, expiresAt?: number): void {\n    try {\n      localStorage.setItem(this.keys.ACCESS_TOKEN, token);\n      if (expiresAt) {\n        localStorage.setItem(this.keys.EXPIRES_AT, String(expiresAt));\n      }\n    } catch (e) {\n      console.warn('[ValtechAuth] Error guardando access token:', e);\n    }\n  }\n\n  /**\n   * Guarda los permisos actualizados.\n   */\n  savePermissions(response: GetPermissionsResponse): void {\n    try {\n      localStorage.setItem(this.keys.ROLES, JSON.stringify(response.roles));\n      localStorage.setItem(\n        this.keys.PERMISSIONS,\n        JSON.stringify(response.permissions)\n      );\n      localStorage.setItem(\n        this.keys.IS_SUPER_ADMIN,\n        String(response.isSuperAdmin)\n      );\n    } catch (e) {\n      console.warn('[ValtechAuth] Error guardando permisos:', e);\n    }\n  }\n\n  /**\n   * Carga los permisos desde storage.\n   */\n  loadPermissions(): {\n    roles: string[];\n    permissions: string[];\n    isSuperAdmin: boolean;\n  } {\n    try {\n      const rolesJson = localStorage.getItem(this.keys.ROLES);\n      const permissionsJson = localStorage.getItem(this.keys.PERMISSIONS);\n      const isSuperAdmin =\n        localStorage.getItem(this.keys.IS_SUPER_ADMIN) === 'true';\n\n      return {\n        roles: rolesJson ? JSON.parse(rolesJson) : [],\n        permissions: permissionsJson ? JSON.parse(permissionsJson) : [],\n        isSuperAdmin,\n      };\n    } catch {\n      return { roles: [], permissions: [], isSuperAdmin: false };\n    }\n  }\n\n  /**\n   * Obtiene el refresh token.\n   */\n  getRefreshToken(): string | null {\n    return localStorage.getItem(this.keys.REFRESH_TOKEN);\n  }\n\n  /**\n   * Limpia todo el estado de autenticación.\n   */\n  clear(): void {\n    try {\n      Object.values(this.keys).forEach((key) => localStorage.removeItem(key));\n    } catch (e) {\n      console.warn('[ValtechAuth] Error limpiando storage:', e);\n    }\n  }\n\n  /**\n   * Verifica si hay estado guardado.\n   */\n  hasStoredState(): boolean {\n    return !!localStorage.getItem(this.keys.ACCESS_TOKEN);\n  }\n}\n"]}