valtech-components 2.0.795 → 2.0.796

package/esm2022/lib/services/app-config/config.mjs

@@ -0,0 +1,47 @@
+import { APP_INITIALIZER, InjectionToken, makeEnvironmentProviders, } from '@angular/core';
+import { DEFAULT_APP_CONFIG_SERVICE_CONFIG, } from './types';
+import { AppConfigService } from './app-config.service';
+/**
+ * Token de inyección para la configuración de AppConfig.
+ */
+export const VALTECH_APP_CONFIG = new InjectionToken('ValtechAppConfig');
+/**
+ * Provee el servicio de configuración remota a la aplicación Angular.
+ *
+ * @param config - Configuración del servicio
+ * @returns EnvironmentProviders para usar en bootstrapApplication
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { provideValtechAppConfig } from 'valtech-components';
+ * import { version } from '../package.json';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechFirebase(environment.valtechFirebase),
+ *     provideValtechAppConfig({
+ *       currentVersion: version,
+ *       showUpdateBanner: true,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export function provideValtechAppConfig(config) {
+    const mergedConfig = {
+        ...DEFAULT_APP_CONFIG_SERVICE_CONFIG,
+        ...config,
+    };
+    return makeEnvironmentProviders([
+        { provide: VALTECH_APP_CONFIG, useValue: mergedConfig },
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (appConfigService) => () => appConfigService.initialize(),
+            deps: [AppConfigService],
+            multi: true,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/app-config/index.mjs

@@ -0,0 +1,48 @@
+/**
+ * AppConfig Service Module
+ *
+ * Servicio de configuración remota para aplicaciones Angular.
+ * Lee configuración desde Firestore y provee feature flags, variables dinámicas,
+ * y detección de actualizaciones.
+ *
+ * Soporta detección de versión cross-platform (web y mobile con Capacitor).
+ *
+ * @example
+ * ```typescript
+ * // main.ts - Con soporte cross-platform
+ * import { provideValtechAppConfig, getAppVersion } from 'valtech-components';
+ * import { version } from '../package.json';
+ *
+ * async function bootstrap() {
+ *   const appVersion = await getAppVersion(version);
+ *
+ *   bootstrapApplication(AppComponent, {
+ *     providers: [
+ *       provideValtechFirebase(environment.valtechFirebase),
+ *       provideValtechAppConfig({
+ *         currentVersion: appVersion,
+ *         showUpdateBanner: true,
+ *       }),
+ *     ],
+ *   });
+ * }
+ * bootstrap();
+ *
+ * // component.ts
+ * import { AppConfigService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   private appConfig = inject(AppConfigService);
+ *
+ *   showFeature = computed(() =>
+ *     this.appConfig.isFeatureEnabled('newDashboard')
+ *   );
+ * }
+ * ```
+ */
+export * from './types';
+export { VALTECH_APP_CONFIG, provideValtechAppConfig } from './config';
+export { AppConfigService } from './app-config.service';
+export { getAppVersion, getAppInfo } from './version';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/app-config/types.mjs

@@ -0,0 +1,13 @@
+/**
+ * AppConfig Types
+ *
+ * Tipos para el servicio de configuración remota de la aplicación.
+ */
+/**
+ * Configuración por defecto del servicio.
+ */
+export const DEFAULT_APP_CONFIG_SERVICE_CONFIG = {
+    currentVersion: '0.0.0',
+    showUpdateBanner: true,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/app-config/version.mjs

@@ -0,0 +1,85 @@
+/**
+ * Cross-Platform Version Helpers
+ *
+ * Funciones para obtener la versión de la aplicación de forma
+ * cross-platform (web y mobile con Capacitor).
+ */
+import { Capacitor } from '@capacitor/core';
+/**
+ * Obtiene la versión de la aplicación de forma cross-platform.
+ *
+ * - En web: retorna la versión de package.json (pasada como parámetro)
+ * - En mobile: usa @capacitor/app para obtener la versión nativa
+ *
+ * @param webVersion - Versión de package.json para fallback en web
+ * @returns Promise<string> - La versión actual de la app
+ *
+ * @example
+ * ```typescript
+ * import { getAppVersion } from 'valtech-components';
+ * import { version } from '../package.json';
+ *
+ * const appVersion = await getAppVersion(version);
+ *
+ * // Uso en main.ts
+ * async function bootstrap() {
+ *   const appVersion = await getAppVersion(version);
+ *   bootstrapApplication(AppComponent, {
+ *     providers: [
+ *       provideValtechAppConfig({ currentVersion: appVersion }),
+ *     ],
+ *   });
+ * }
+ * bootstrap();
+ * ```
+ */
+export async function getAppVersion(webVersion) {
+    // En web, siempre usar la versión de package.json
+    if (!Capacitor.isNativePlatform()) {
+        return webVersion;
+    }
+    // En native (iOS/Android), obtener versión del binario
+    try {
+        const { App } = await import('@capacitor/app');
+        const info = await App.getInfo();
+        return info.version;
+    }
+    catch (error) {
+        console.warn('[getAppVersion] Failed to get native version, using fallback:', error);
+        return webVersion;
+    }
+}
+/**
+ * Obtiene información completa de la app (solo en nativo).
+ * En web retorna null.
+ *
+ * @returns Promise<AppVersionInfo | null> - Info completa o null en web
+ *
+ * @example
+ * ```typescript
+ * const info = await getAppInfo();
+ * if (info) {
+ *   console.log(`App: ${info.name} v${info.version} (build ${info.build})`);
+ *   console.log(`Bundle ID: ${info.id}`);
+ * }
+ * ```
+ */
+export async function getAppInfo() {
+    if (!Capacitor.isNativePlatform()) {
+        return null;
+    }
+    try {
+        const { App } = await import('@capacitor/app');
+        const info = await App.getInfo();
+        return {
+            version: info.version,
+            build: info.build,
+            name: info.name,
+            id: info.id,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/auth/auth-state.service.mjs

@@ -0,0 +1,207 @@
+import { Injectable, signal, computed } from '@angular/core';
+import { INITIAL_AUTH_STATE, INITIAL_MFA_STATE, } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para manejo de estado de autenticación con Angular Signals.
+ * Proporciona estado reactivo inmutable.
+ */
+export class AuthStateService {
+    constructor() {
+        // Estado interno (mutable solo dentro del servicio)
+        this._state = signal(INITIAL_AUTH_STATE);
+        this._mfaPending = signal(INITIAL_MFA_STATE);
+        // =============================================
+        // Signals públicos (readonly)
+        // =============================================
+        /** Estado completo de autenticación */
+        this.state = this._state.asReadonly();
+        /** Estado de MFA pendiente */
+        this.mfaPending = this._mfaPending.asReadonly();
+        /** Usuario está autenticado */
+        this.isAuthenticated = computed(() => this._state().isAuthenticated);
+        /** Estado de carga */
+        this.isLoading = computed(() => this._state().isLoading);
+        /** Token de acceso */
+        this.accessToken = computed(() => this._state().accessToken);
+        /** Roles del usuario */
+        this.roles = computed(() => this._state().roles);
+        /** Permisos del usuario */
+        this.permissions = computed(() => this._state().permissions);
+        /** Usuario es super admin */
+        this.isSuperAdmin = computed(() => this._state().isSuperAdmin);
+        /** Usuario tiene suscripción premium activa (no ve ads) */
+        this.isPremium = computed(() => this._state().isPremium);
+        /** Error actual */
+        this.error = computed(() => this._state().error);
+        /** Información del usuario */
+        this.user = computed(() => {
+            const state = this._state();
+            if (!state.isAuthenticated || !state.userId) {
+                return null;
+            }
+            return {
+                userId: state.userId,
+                email: state.email || '',
+                name: state.name ?? undefined,
+                handle: state.handle ?? undefined,
+                avatarUrl: state.avatarUrl ?? undefined,
+                phone: state.phone ?? undefined,
+                roles: state.roles,
+                permissions: state.permissions,
+                isSuperAdmin: state.isSuperAdmin,
+            };
+        });
+    }
+    // =============================================
+    // Métodos de actualización
+    // =============================================
+    /**
+     * Establece el estado de carga.
+     */
+    setLoading(isLoading) {
+        this._state.update(s => ({ ...s, isLoading }));
+    }
+    /**
+     * Establece el estado de autenticación exitosa.
+     */
+    setAuthenticated(data) {
+        this._state.set({
+            isAuthenticated: true,
+            isLoading: false,
+            accessToken: data.accessToken,
+            refreshToken: data.refreshToken,
+            userId: data.userId || null,
+            email: data.email || null,
+            roles: data.roles,
+            permissions: data.permissions,
+            isSuperAdmin: data.isSuperAdmin,
+            isPremium: data.isPremium || false,
+            expiresAt: data.expiresAt,
+            error: null,
+        });
+    }
+    /**
+     * Actualiza solo el access token (después de refresh).
+     */
+    updateAccessToken(accessToken, expiresIn) {
+        const expiresAt = Date.now() + expiresIn * 1000;
+        this._state.update(s => ({
+            ...s,
+            accessToken,
+            expiresAt,
+        }));
+    }
+    /**
+     * Actualiza el refresh token (token rotation).
+     */
+    updateRefreshToken(refreshToken) {
+        this._state.update(s => ({
+            ...s,
+            refreshToken,
+        }));
+    }
+    /**
+     * Actualiza los permisos.
+     */
+    updatePermissions(roles, permissions, isSuperAdmin) {
+        this._state.update(s => ({
+            ...s,
+            roles,
+            permissions,
+            isSuperAdmin,
+        }));
+    }
+    /**
+     * Establece un error de autenticación.
+     */
+    setError(error) {
+        this._state.update(s => ({
+            ...s,
+            error,
+            isLoading: false,
+        }));
+    }
+    /**
+     * Limpia el error.
+     */
+    clearError() {
+        this._state.update(s => ({
+            ...s,
+            error: null,
+        }));
+    }
+    /**
+     * Establece estado de MFA pendiente.
+     */
+    setMFAPending(mfaState) {
+        this._mfaPending.set(mfaState);
+    }
+    /**
+     * Limpia el estado de MFA pendiente.
+     */
+    clearMFAPending() {
+        this._mfaPending.set(INITIAL_MFA_STATE);
+    }
+    /**
+     * Resetea todo el estado a valores iniciales.
+     */
+    reset() {
+        this._state.set(INITIAL_AUTH_STATE);
+        this._mfaPending.set(INITIAL_MFA_STATE);
+    }
+    /**
+     * Restaura estado desde datos almacenados.
+     */
+    restoreFromStorage(stored) {
+        if (stored.accessToken) {
+            this._state.set({
+                isAuthenticated: true,
+                isLoading: false,
+                accessToken: stored.accessToken,
+                refreshToken: stored.refreshToken || null,
+                userId: null, // Se extraerá del token
+                email: null, // Se extraerá del token
+                roles: stored.roles || [],
+                permissions: stored.permissions || [],
+                isSuperAdmin: stored.isSuperAdmin || false,
+                isPremium: stored.isPremium || false,
+                expiresAt: stored.expiresAt || null,
+                error: null,
+            });
+        }
+    }
+    /**
+     * Actualiza el userId y email (después de parsear el token).
+     */
+    updateUserInfo(userId, email) {
+        this._state.update(s => ({
+            ...s,
+            userId,
+            email,
+        }));
+    }
+    /**
+     * Hidrata el state con campos del profile (nombre, handle, avatar, phone).
+     * Invocado tras `getProfile()` o `updateProfile()` para que consumers de
+     * `auth.user()` vean los campos enriched automáticamente.
+     *
+     * Cualquier campo `undefined` se ignora (no sobrescribe con null). Campos
+     * `null` explícitos se persisten (signal de "limpiado").
+     */
+    updateProfileFields(fields) {
+        this._state.update(s => ({
+            ...s,
+            ...(fields.name !== undefined && { name: fields.name }),
+            ...(fields.handle !== undefined && { handle: fields.handle }),
+            ...(fields.avatarUrl !== undefined && { avatarUrl: fields.avatarUrl }),
+            ...(fields.phone !== undefined && { phone: fields.phone }),
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthStateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthStateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-state.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/auth-state.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAKL,kBAAkB,EAClB,iBAAiB,GAElB,MAAM,SAAS,CAAC;;AAEjB;;;GAGG;AAEH,MAAM,OAAO,gBAAgB;IAD7B;QAEE,oDAAoD;QAC5C,WAAM,GAAG,MAAM,CAAY,kBAAkB,CAAC,CAAC;QAC/C,gBAAW,GAAG,MAAM,CAAkB,iBAAiB,CAAC,CAAC;QAEjE,gDAAgD;QAChD,8BAA8B;QAC9B,gDAAgD;QAEhD,uCAAuC;QAC9B,UAAK,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAE1C,8BAA8B;QACrB,eAAU,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;QAEpD,+BAA+B;QACtB,oBAAe,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,CAAC;QAEzE,sBAAsB;QACb,cAAS,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,SAAS,CAAC,CAAC;QAE7D,sBAAsB;QACb,gBAAW,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC;QAEjE,wBAAwB;QACf,UAAK,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC;QAErD,2BAA2B;QAClB,gBAAW,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC;QAEjE,6BAA6B;QACpB,iBAAY,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,YAAY,CAAC,CAAC;QAEnE,2DAA2D;QAClD,cAAS,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,SAAS,CAAC,CAAC;QAE7D,mBAAmB;QACV,UAAK,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC;QAErD,8BAA8B;QACrB,SAAI,GAAG,QAAQ,CAAkB,GAAG,EAAE;YAC7C,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAC5B,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;gBAC5C,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO;gBACL,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,EAAE;gBACxB,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,SAAS;gBAC7B,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,SAAS;gBACjC,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,SAAS;gBACvC,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,SAAS;gBAC/B,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,WAAW,EAAE,KAAK,CAAC,WAAW;gBAC9B,YAAY,EAAE,KAAK,CAAC,YAAY;aACjC,CAAC;QACJ,CAAC,CAAC,CAAC;KA+KJ;IA7KC,gDAAgD;IAChD,2BAA2B;IAC3B,gDAAgD;IAEhD;;OAEG;IACH,UAAU,CAAC,SAAkB;QAC3B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IACjD,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,IAUhB;QACC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;YACd,eAAe,EAAE,IAAI;YACrB,SAAS,EAAE,KAAK;YAChB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,IAAI;YAC3B,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,IAAI;YACzB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,SAAS,EAAE,IAAI,CAAC,SAAS,IAAI,KAAK;YAClC,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,KAAK,EAAE,IAAI;SACZ,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,iBAAiB,CAAC,WAAmB,EAAE,SAAiB;QACtD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,IAAI,CAAC;QAChD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACvB,GAAG,CAAC;YACJ,WAAW;YACX,SAAS;SACV,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,YAAoB;QACrC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACvB,GAAG,CAAC;YACJ,YAAY;SACb,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACH,iBAAiB,CAAC,KAAe,EAAE,WAAqB,EAAE,YAAqB;QAC7E,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACvB,GAAG,CAAC;YACJ,KAAK;YACL,WAAW;YACX,YAAY;SACb,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,KAAgB;QACvB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACvB,GAAG,CAAC;YACJ,KAAK;YACL,SAAS,EAAE,KAAK;SACjB,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACH,UAAU;QACR,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACvB,GAAG,CAAC;YACJ,KAAK,EAAE,IAAI;SACZ,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,QAAyB;QACrC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,eAAe;QACb,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QACpC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,MAAgC;QACjD,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;gBACd,eAAe,EAAE,IAAI;gBACrB,SAAS,EAAE,KAAK;gBAChB,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,YAAY,EAAE,MAAM,CAAC,YAAY,IAAI,IAAI;gBACzC,MAAM,EAAE,IAAI,EAAE,wBAAwB;gBACtC,KAAK,EAAE,IAAI,EAAE,wBAAwB;gBACrC,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,EAAE;gBACzB,WAAW,EAAE,MAAM,CAAC,WAAW,IAAI,EAAE;gBACrC,YAAY,EAAE,MAAM,CAAC,YAAY,IAAI,KAAK;gBAC1C,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,KAAK;gBACpC,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,IAAI;gBACnC,KAAK,EAAE,IAAI;aACZ,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;OAEG;IACH,cAAc,CAAC,MAAc,EAAE,KAAa;QAC1C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACvB,GAAG,CAAC;YACJ,MAAM;YACN,KAAK;SACN,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;;;;;;OAOG;IACH,mBAAmB,CAAC,MAKnB;QACC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACvB,GAAG,CAAC;YACJ,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;YACvD,GAAG,CAAC,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;YAC7D,GAAG,CAAC,MAAM,CAAC,SAAS,KAAK,SAAS,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC;YACtE,GAAG,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;SAC3D,CAAC,CAAC,CAAC;IACN,CAAC;+GAtOU,gBAAgB;mHAAhB,gBAAgB,cADH,MAAM;;4FACnB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable, signal, computed } from '@angular/core';\nimport {\n  AuthState,\n  AuthUser,\n  AuthError,\n  MFAPendingState,\n  INITIAL_AUTH_STATE,\n  INITIAL_MFA_STATE,\n  StoredAuthState,\n} from './types';\n\n/**\n * Servicio para manejo de estado de autenticación con Angular Signals.\n * Proporciona estado reactivo inmutable.\n */\n@Injectable({ providedIn: 'root' })\nexport class AuthStateService {\n  // Estado interno (mutable solo dentro del servicio)\n  private _state = signal<AuthState>(INITIAL_AUTH_STATE);\n  private _mfaPending = signal<MFAPendingState>(INITIAL_MFA_STATE);\n\n  // =============================================\n  // Signals públicos (readonly)\n  // =============================================\n\n  /** Estado completo de autenticación */\n  readonly state = this._state.asReadonly();\n\n  /** Estado de MFA pendiente */\n  readonly mfaPending = this._mfaPending.asReadonly();\n\n  /** Usuario está autenticado */\n  readonly isAuthenticated = computed(() => this._state().isAuthenticated);\n\n  /** Estado de carga */\n  readonly isLoading = computed(() => this._state().isLoading);\n\n  /** Token de acceso */\n  readonly accessToken = computed(() => this._state().accessToken);\n\n  /** Roles del usuario */\n  readonly roles = computed(() => this._state().roles);\n\n  /** Permisos del usuario */\n  readonly permissions = computed(() => this._state().permissions);\n\n  /** Usuario es super admin */\n  readonly isSuperAdmin = computed(() => this._state().isSuperAdmin);\n\n  /** Usuario tiene suscripción premium activa (no ve ads) */\n  readonly isPremium = computed(() => this._state().isPremium);\n\n  /** Error actual */\n  readonly error = computed(() => this._state().error);\n\n  /** Información del usuario */\n  readonly user = computed<AuthUser | null>(() => {\n    const state = this._state();\n    if (!state.isAuthenticated || !state.userId) {\n      return null;\n    }\n    return {\n      userId: state.userId,\n      email: state.email || '',\n      name: state.name ?? undefined,\n      handle: state.handle ?? undefined,\n      avatarUrl: state.avatarUrl ?? undefined,\n      phone: state.phone ?? undefined,\n      roles: state.roles,\n      permissions: state.permissions,\n      isSuperAdmin: state.isSuperAdmin,\n    };\n  });\n\n  // =============================================\n  // Métodos de actualización\n  // =============================================\n\n  /**\n   * Establece el estado de carga.\n   */\n  setLoading(isLoading: boolean): void {\n    this._state.update(s => ({ ...s, isLoading }));\n  }\n\n  /**\n   * Establece el estado de autenticación exitosa.\n   */\n  setAuthenticated(data: {\n    accessToken: string;\n    refreshToken: string;\n    userId?: string;\n    email?: string;\n    roles: string[];\n    permissions: string[];\n    isSuperAdmin: boolean;\n    isPremium?: boolean;\n    expiresAt: number;\n  }): void {\n    this._state.set({\n      isAuthenticated: true,\n      isLoading: false,\n      accessToken: data.accessToken,\n      refreshToken: data.refreshToken,\n      userId: data.userId || null,\n      email: data.email || null,\n      roles: data.roles,\n      permissions: data.permissions,\n      isSuperAdmin: data.isSuperAdmin,\n      isPremium: data.isPremium || false,\n      expiresAt: data.expiresAt,\n      error: null,\n    });\n  }\n\n  /**\n   * Actualiza solo el access token (después de refresh).\n   */\n  updateAccessToken(accessToken: string, expiresIn: number): void {\n    const expiresAt = Date.now() + expiresIn * 1000;\n    this._state.update(s => ({\n      ...s,\n      accessToken,\n      expiresAt,\n    }));\n  }\n\n  /**\n   * Actualiza el refresh token (token rotation).\n   */\n  updateRefreshToken(refreshToken: string): void {\n    this._state.update(s => ({\n      ...s,\n      refreshToken,\n    }));\n  }\n\n  /**\n   * Actualiza los permisos.\n   */\n  updatePermissions(roles: string[], permissions: string[], isSuperAdmin: boolean): void {\n    this._state.update(s => ({\n      ...s,\n      roles,\n      permissions,\n      isSuperAdmin,\n    }));\n  }\n\n  /**\n   * Establece un error de autenticación.\n   */\n  setError(error: AuthError): void {\n    this._state.update(s => ({\n      ...s,\n      error,\n      isLoading: false,\n    }));\n  }\n\n  /**\n   * Limpia el error.\n   */\n  clearError(): void {\n    this._state.update(s => ({\n      ...s,\n      error: null,\n    }));\n  }\n\n  /**\n   * Establece estado de MFA pendiente.\n   */\n  setMFAPending(mfaState: MFAPendingState): void {\n    this._mfaPending.set(mfaState);\n  }\n\n  /**\n   * Limpia el estado de MFA pendiente.\n   */\n  clearMFAPending(): void {\n    this._mfaPending.set(INITIAL_MFA_STATE);\n  }\n\n  /**\n   * Resetea todo el estado a valores iniciales.\n   */\n  reset(): void {\n    this._state.set(INITIAL_AUTH_STATE);\n    this._mfaPending.set(INITIAL_MFA_STATE);\n  }\n\n  /**\n   * Restaura estado desde datos almacenados.\n   */\n  restoreFromStorage(stored: Partial<StoredAuthState>): void {\n    if (stored.accessToken) {\n      this._state.set({\n        isAuthenticated: true,\n        isLoading: false,\n        accessToken: stored.accessToken,\n        refreshToken: stored.refreshToken || null,\n        userId: null, // Se extraerá del token\n        email: null, // Se extraerá del token\n        roles: stored.roles || [],\n        permissions: stored.permissions || [],\n        isSuperAdmin: stored.isSuperAdmin || false,\n        isPremium: stored.isPremium || false,\n        expiresAt: stored.expiresAt || null,\n        error: null,\n      });\n    }\n  }\n\n  /**\n   * Actualiza el userId y email (después de parsear el token).\n   */\n  updateUserInfo(userId: string, email: string): void {\n    this._state.update(s => ({\n      ...s,\n      userId,\n      email,\n    }));\n  }\n\n  /**\n   * Hidrata el state con campos del profile (nombre, handle, avatar, phone).\n   * Invocado tras `getProfile()` o `updateProfile()` para que consumers de\n   * `auth.user()` vean los campos enriched automáticamente.\n   *\n   * Cualquier campo `undefined` se ignora (no sobrescribe con null). Campos\n   * `null` explícitos se persisten (signal de \"limpiado\").\n   */\n  updateProfileFields(fields: {\n    name?: string | null;\n    handle?: string | null;\n    avatarUrl?: string | null;\n    phone?: string | null;\n  }): void {\n    this._state.update(s => ({\n      ...s,\n      ...(fields.name !== undefined && { name: fields.name }),\n      ...(fields.handle !== undefined && { handle: fields.handle }),\n      ...(fields.avatarUrl !== undefined && { avatarUrl: fields.avatarUrl }),\n      ...(fields.phone !== undefined && { phone: fields.phone }),\n    }));\n  }\n}\n"]}