valtech-components 2.0.576 → 2.0.578

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

@@ -0,0 +1,221 @@
+import { Injectable, Inject, signal, computed } from '@angular/core';
+import { from, throwError } from 'rxjs';
+import { catchError, switchMap, tap } from 'rxjs/operators';
+import { GoogleAuth } from '@codetrix-studio/capacitor-google-auth';
+import { VALTECH_AUTH_CONFIG } from './config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Servicio de autenticación con Google usando SDK nativo.
+ *
+ * Este servicio utiliza `@codetrix-studio/capacitor-google-auth` que funciona
+ * tanto en web como en aplicaciones Capacitor (iOS/Android).
+ *
+ * Para web, utiliza el popup nativo de Google Sign-In.
+ * Para mobile, utiliza el SDK nativo de Google.
+ *
+ * @example
+ * ```typescript
+ * // En main.ts o app.config.ts
+ * import { provideGoogleAuth } from 'valtech-components';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideGoogleAuth({
+ *       clientId: 'your-google-client-id.apps.googleusercontent.com'
+ *     })
+ *   ]
+ * };
+ *
+ * // En el componente
+ * import { GoogleAuthService, AuthService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class LoginComponent {
+ *   private googleAuth = inject(GoogleAuthService);
+ *   private auth = inject(AuthService);
+ *
+ *   async signInWithGoogle() {
+ *     this.googleAuth.signIn().subscribe({
+ *       next: (result) => {
+ *         // Tokens recibidos del backend
+ *         this.auth.handleOAuthSuccess(result);
+ *         this.router.navigate(['/']);
+ *       },
+ *       error: (error) => {
+ *         console.error('Google sign-in failed:', error);
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export class GoogleAuthService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+        this.initialized = signal(false);
+        this.googleConfig = null;
+        /** Indica si el servicio está inicializado */
+        this.isInitialized = computed(() => this.initialized());
+    }
+    /**
+     * Inicializa el SDK de Google Sign-In.
+     * Debe llamarse una vez, idealmente en APP_INITIALIZER.
+     *
+     * @param googleConfig - Configuración de Google Auth
+     */
+    async initialize(googleConfig) {
+        if (this.initialized()) {
+            console.log('[GoogleAuth] Already initialized');
+            return;
+        }
+        this.googleConfig = googleConfig;
+        try {
+            await GoogleAuth.initialize({
+                clientId: googleConfig.clientId,
+                scopes: googleConfig.scopes || ['email', 'profile'],
+                grantOfflineAccess: true,
+            });
+            this.initialized.set(true);
+            console.log('[GoogleAuth] Initialized successfully');
+        }
+        catch (error) {
+            console.error('[GoogleAuth] Initialization failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Inicia el flujo de Google Sign-In y obtiene tokens del backend.
+     *
+     * El flujo es:
+     * 1. Abre popup/SDK nativo de Google
+     * 2. Usuario autoriza
+     * 3. Obtiene ID token de Google
+     * 4. Envía ID token al backend para verificación
+     * 5. Backend verifica con Google y retorna nuestros JWT tokens
+     *
+     * @returns Observable con la respuesta del backend (tokens)
+     */
+    signIn() {
+        if (!this.initialized()) {
+            return throwError(() => ({
+                code: 'NOT_INITIALIZED',
+                message: 'GoogleAuthService no está inicializado. Llama a initialize() primero.',
+            }));
+        }
+        return from(this.performGoogleSignIn()).pipe(tap(googleUser => {
+            console.log('[GoogleAuth] Google sign-in successful:', {
+                email: googleUser.email,
+                hasIdToken: !!googleUser.idToken,
+                idTokenLength: googleUser.idToken?.length || 0,
+            });
+        }), switchMap(googleUser => this.verifyWithBackend(googleUser)), catchError(error => {
+            console.error('[GoogleAuth] Sign-in error:', error);
+            // Handle Google SDK specific errors
+            if (error?.message?.includes('popup_closed') || error?.code === 'popup_closed_by_user') {
+                return throwError(() => ({
+                    code: 'POPUP_CLOSED',
+                    message: 'Se cerró la ventana de autenticación de Google',
+                }));
+            }
+            if (error?.message?.includes('access_denied') || error?.code === 'access_denied') {
+                return throwError(() => ({
+                    code: 'ACCESS_DENIED',
+                    message: 'El usuario denegó el acceso a Google',
+                }));
+            }
+            // Backend errors pass through
+            if (error.code && error.message) {
+                return throwError(() => error);
+            }
+            return throwError(() => ({
+                code: 'GOOGLE_AUTH_ERROR',
+                message: error?.message || 'Error al iniciar sesión con Google',
+            }));
+        }));
+    }
+    /**
+     * Cierra la sesión de Google.
+     * Nota: Esto solo cierra la sesión del SDK de Google,
+     * NO cierra la sesión del backend. Usa AuthService.logout() para eso.
+     */
+    async signOut() {
+        try {
+            await GoogleAuth.signOut();
+            console.log('[GoogleAuth] Signed out from Google');
+        }
+        catch (error) {
+            console.warn('[GoogleAuth] Sign out error:', error);
+        }
+    }
+    /**
+     * Obtiene el token de autenticación refrescado (si existe sesión).
+     * Nota: GoogleAuth.refresh() solo retorna tokens, no info del usuario.
+     */
+    async refreshToken() {
+        try {
+            const auth = await GoogleAuth.refresh();
+            if (auth?.idToken) {
+                return {
+                    idToken: auth.idToken,
+                    accessToken: auth.accessToken,
+                };
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Realiza el sign-in con Google usando el SDK nativo.
+     */
+    async performGoogleSignIn() {
+        const user = await GoogleAuth.signIn();
+        if (!user?.authentication?.idToken) {
+            throw new Error('No se obtuvo ID token de Google');
+        }
+        return {
+            id: user.id || '',
+            email: user.email || '',
+            name: user.name || '',
+            imageUrl: user.imageUrl,
+            idToken: user.authentication.idToken,
+            accessToken: user.authentication.accessToken,
+        };
+    }
+    /**
+     * Verifica el ID token de Google con nuestro backend.
+     */
+    verifyWithBackend(googleUser) {
+        const request = {
+            idToken: googleUser.idToken,
+        };
+        const url = `${this.config.apiUrl}/v2/auth/oauth/google/verify`;
+        return this.http.post(url, request).pipe(tap(response => {
+            console.log('[GoogleAuth] Backend verification successful:', {
+                hasAccessToken: !!response.accessToken,
+                hasFirebaseToken: !!response.firebaseToken,
+                isNewUser: response.isNewUser,
+            });
+        }), catchError(error => {
+            console.error('[GoogleAuth] Backend verification failed:', error);
+            const authError = {
+                code: error.error?.code || 'VERIFICATION_ERROR',
+                message: error.error?.message || 'Error al verificar credenciales de Google',
+            };
+            return throwError(() => authError);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GoogleAuthService, 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: GoogleAuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GoogleAuthService, 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":"google-auth.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/google-auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, signal, computed } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, from, throwError } from 'rxjs';\nimport { map, catchError, switchMap, tap } from 'rxjs/operators';\nimport { GoogleAuth } from '@codetrix-studio/capacitor-google-auth';\nimport { VALTECH_AUTH_CONFIG } from './config';\nimport {\n  ValtechAuthConfig,\n  GoogleAuthConfig,\n  GoogleUser,\n  VerifyGoogleTokenRequest,\n  VerifyGoogleTokenResponse,\n  AuthError,\n} from './types';\n\n/**\n * Servicio de autenticación con Google usando SDK nativo.\n *\n * Este servicio utiliza `@codetrix-studio/capacitor-google-auth` que funciona\n * tanto en web como en aplicaciones Capacitor (iOS/Android).\n *\n * Para web, utiliza el popup nativo de Google Sign-In.\n * Para mobile, utiliza el SDK nativo de Google.\n *\n * @example\n * ```typescript\n * // En main.ts o app.config.ts\n * import { provideGoogleAuth } from 'valtech-components';\n *\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     provideGoogleAuth({\n *       clientId: 'your-google-client-id.apps.googleusercontent.com'\n *     })\n *   ]\n * };\n *\n * // En el componente\n * import { GoogleAuthService, AuthService } from 'valtech-components';\n *\n * @Component({...})\n * export class LoginComponent {\n *   private googleAuth = inject(GoogleAuthService);\n *   private auth = inject(AuthService);\n *\n *   async signInWithGoogle() {\n *     this.googleAuth.signIn().subscribe({\n *       next: (result) => {\n *         // Tokens recibidos del backend\n *         this.auth.handleOAuthSuccess(result);\n *         this.router.navigate(['/']);\n *       },\n *       error: (error) => {\n *         console.error('Google sign-in failed:', error);\n *       }\n *     });\n *   }\n * }\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class GoogleAuthService {\n  private initialized = signal(false);\n  private googleConfig: GoogleAuthConfig | null = null;\n\n  /** Indica si el servicio está inicializado */\n  readonly isInitialized = computed(() => this.initialized());\n\n  constructor(\n    @Inject(VALTECH_AUTH_CONFIG) private config: ValtechAuthConfig,\n    private http: HttpClient\n  ) {}\n\n  /**\n   * Inicializa el SDK de Google Sign-In.\n   * Debe llamarse una vez, idealmente en APP_INITIALIZER.\n   *\n   * @param googleConfig - Configuración de Google Auth\n   */\n  async initialize(googleConfig: GoogleAuthConfig): Promise<void> {\n    if (this.initialized()) {\n      console.log('[GoogleAuth] Already initialized');\n      return;\n    }\n\n    this.googleConfig = googleConfig;\n\n    try {\n      await GoogleAuth.initialize({\n        clientId: googleConfig.clientId,\n        scopes: googleConfig.scopes || ['email', 'profile'],\n        grantOfflineAccess: true,\n      });\n\n      this.initialized.set(true);\n      console.log('[GoogleAuth] Initialized successfully');\n    } catch (error) {\n      console.error('[GoogleAuth] Initialization failed:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Inicia el flujo de Google Sign-In y obtiene tokens del backend.\n   *\n   * El flujo es:\n   * 1. Abre popup/SDK nativo de Google\n   * 2. Usuario autoriza\n   * 3. Obtiene ID token de Google\n   * 4. Envía ID token al backend para verificación\n   * 5. Backend verifica con Google y retorna nuestros JWT tokens\n   *\n   * @returns Observable con la respuesta del backend (tokens)\n   */\n  signIn(): Observable<VerifyGoogleTokenResponse> {\n    if (!this.initialized()) {\n      return throwError(() => ({\n        code: 'NOT_INITIALIZED',\n        message: 'GoogleAuthService no está inicializado. Llama a initialize() primero.',\n      } as AuthError));\n    }\n\n    return from(this.performGoogleSignIn()).pipe(\n      tap(googleUser => {\n        console.log('[GoogleAuth] Google sign-in successful:', {\n          email: googleUser.email,\n          hasIdToken: !!googleUser.idToken,\n          idTokenLength: googleUser.idToken?.length || 0,\n        });\n      }),\n      switchMap(googleUser => this.verifyWithBackend(googleUser)),\n      catchError(error => {\n        console.error('[GoogleAuth] Sign-in error:', error);\n\n        // Handle Google SDK specific errors\n        if (error?.message?.includes('popup_closed') || error?.code === 'popup_closed_by_user') {\n          return throwError(() => ({\n            code: 'POPUP_CLOSED',\n            message: 'Se cerró la ventana de autenticación de Google',\n          } as AuthError));\n        }\n\n        if (error?.message?.includes('access_denied') || error?.code === 'access_denied') {\n          return throwError(() => ({\n            code: 'ACCESS_DENIED',\n            message: 'El usuario denegó el acceso a Google',\n          } as AuthError));\n        }\n\n        // Backend errors pass through\n        if (error.code && error.message) {\n          return throwError(() => error);\n        }\n\n        return throwError(() => ({\n          code: 'GOOGLE_AUTH_ERROR',\n          message: error?.message || 'Error al iniciar sesión con Google',\n        } as AuthError));\n      })\n    );\n  }\n\n  /**\n   * Cierra la sesión de Google.\n   * Nota: Esto solo cierra la sesión del SDK de Google,\n   * NO cierra la sesión del backend. Usa AuthService.logout() para eso.\n   */\n  async signOut(): Promise<void> {\n    try {\n      await GoogleAuth.signOut();\n      console.log('[GoogleAuth] Signed out from Google');\n    } catch (error) {\n      console.warn('[GoogleAuth] Sign out error:', error);\n    }\n  }\n\n  /**\n   * Obtiene el token de autenticación refrescado (si existe sesión).\n   * Nota: GoogleAuth.refresh() solo retorna tokens, no info del usuario.\n   */\n  async refreshToken(): Promise<{ idToken: string; accessToken: string } | null> {\n    try {\n      const auth = await GoogleAuth.refresh();\n      if (auth?.idToken) {\n        return {\n          idToken: auth.idToken,\n          accessToken: auth.accessToken,\n        };\n      }\n      return null;\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Realiza el sign-in con Google usando el SDK nativo.\n   */\n  private async performGoogleSignIn(): Promise<GoogleUser> {\n    const user = await GoogleAuth.signIn();\n\n    if (!user?.authentication?.idToken) {\n      throw new Error('No se obtuvo ID token de Google');\n    }\n\n    return {\n      id: user.id || '',\n      email: user.email || '',\n      name: user.name || '',\n      imageUrl: user.imageUrl,\n      idToken: user.authentication.idToken,\n      accessToken: user.authentication.accessToken,\n    };\n  }\n\n  /**\n   * Verifica el ID token de Google con nuestro backend.\n   */\n  private verifyWithBackend(googleUser: GoogleUser): Observable<VerifyGoogleTokenResponse> {\n    const request: VerifyGoogleTokenRequest = {\n      idToken: googleUser.idToken,\n    };\n\n    const url = `${this.config.apiUrl}/v2/auth/oauth/google/verify`;\n\n    return this.http.post<VerifyGoogleTokenResponse>(url, request).pipe(\n      tap(response => {\n        console.log('[GoogleAuth] Backend verification successful:', {\n          hasAccessToken: !!response.accessToken,\n          hasFirebaseToken: !!response.firebaseToken,\n          isNewUser: response.isNewUser,\n        });\n      }),\n      catchError(error => {\n        console.error('[GoogleAuth] Backend verification failed:', error);\n\n        const authError: AuthError = {\n          code: error.error?.code || 'VERIFICATION_ERROR',\n          message: error.error?.message || 'Error al verificar credenciales de Google',\n        };\n\n        return throwError(() => authError);\n      })\n    );\n  }\n}\n"]}

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

@@ -89,4 +89,6 @@ 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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
+// Google Auth (Native SDK - Capacitor compatible)
+export { GoogleAuthService } from './google-auth.service';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -104,38 +104,47 @@ export class OAuthService {
                 });
             };
             window.addEventListener('message', this.messageHandler);
-            // Verificar si popup se cierra - revisar localStorage como fallback (COOP workaround)
+            // Polling de localStorage (COOP workaround - no podemos detectar popup.closed)
+            // También verifica si el popup se cerró manualmente
             this.checkClosedInterval = setInterval(() => {
-                if (this.popup?.closed) {
+                // Primero verificar localStorage (funciona aunque COOP bloquee todo)
+                const storedData = this.checkLocalStorageFallback();
+                if (storedData) {
                     this.cleanup();
-                    // Intentar leer de localStorage (fallback para COOP)
                     this.ngZone.run(() => {
-                        const storedData = this.checkLocalStorageFallback();
-                        if (storedData) {
-                            if (storedData.error) {
-                                observer.error(storedData.error);
-                            }
-                            else if (storedData.tokens) {
-                                console.log('[OAuthService] Retrieved tokens from localStorage fallback');
-                                observer.next(storedData.tokens);
-                                observer.complete();
-                            }
-                            else {
-                                observer.error({
-                                    code: 'INVALID_RESPONSE',
-                                    message: 'Respuesta inválida del servidor de autenticación',
-                                });
-                            }
+                        if (storedData.error) {
+                            observer.error(storedData.error);
+                        }
+                        else if (storedData.tokens) {
+                            console.log('[OAuthService] Retrieved tokens from localStorage fallback');
+                            observer.next(storedData.tokens);
+                            observer.complete();
                         }
                         else {
                             observer.error({
-                                code: 'POPUP_CLOSED',
-                                message: 'Se cerró la ventana de autenticación',
+                                code: 'INVALID_RESPONSE',
+                                message: 'Respuesta inválida del servidor de autenticación',
                             });
                         }
                     });
+                    return;
                 }
-            }, 500);
+                // Intentar verificar si popup se cerró (puede fallar por COOP)
+                try {
+                    if (this.popup?.closed) {
+                        this.cleanup();
+                        this.ngZone.run(() => {
+                            observer.error({
+                                code: 'POPUP_CLOSED',
+                                message: 'Se cerró la ventana de autenticación',
+                            });
+                        });
+                    }
+                }
+                catch {
+                    // COOP bloquea acceso a popup.closed - ignorar y seguir con polling
+                }
+            }, 300);
             // Cleanup cuando el observable se destruye
             return () => this.cleanup();
         });
@@ -306,4 +315,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                     type: Inject,
                     args: [VALTECH_AUTH_CONFIG]
                 }] }, { type: i1.HttpClient }, { type: i0.NgZone }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oauth.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/oauth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, NgZone } from '@angular/core';\nimport { Observable, Subject, throwError } from 'rxjs';\nimport { VALTECH_AUTH_CONFIG } from './config';\nimport {\n  ValtechAuthConfig,\n  OAuthProvider,\n  OAuthResult,\n  OAuthError,\n  OAuthCallbackData,\n  LinkedProvider,\n  HasPasswordResponse,\n} from './types';\nimport { HttpClient } from '@angular/common/http';\nimport { catchError } from 'rxjs/operators';\n\n/**\n * Servicio de OAuth para login social.\n *\n * Implementa flujo OAuth server-side con popup:\n * 1. Frontend abre popup hacia backend\n * 2. Backend redirige a provider (Google, Apple, Microsoft)\n * 3. Usuario autoriza\n * 4. Backend intercambia code, genera JWT, redirige con tokens\n * 5. Popup envía tokens a ventana padre via postMessage\n *\n * @example\n * ```typescript\n * import { OAuthService, AuthService } from 'valtech-components';\n *\n * @Component({...})\n * export class LoginComponent {\n *   private oauth = inject(OAuthService);\n *   private auth = inject(AuthService);\n *\n *   async loginWithGoogle() {\n *     this.oauth.startFlow('google').subscribe({\n *       next: (result) => {\n *         // Tokens recibidos, guardar en auth state\n *         this.auth.handleOAuthSuccess(result);\n *         this.router.navigate(['/']);\n *       },\n *       error: (error) => {\n *         console.error('OAuth failed:', error);\n *       }\n *     });\n *   }\n * }\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class OAuthService {\n  private popup: Window | null = null;\n  private messageHandler: ((event: MessageEvent) => void) | null = null;\n  private checkClosedInterval: ReturnType<typeof setInterval> | null = null;\n\n  constructor(\n    @Inject(VALTECH_AUTH_CONFIG) private config: ValtechAuthConfig,\n    private http: HttpClient,\n    private ngZone: NgZone\n  ) {}\n\n  /**\n   * Inicia flujo OAuth en popup.\n   * Retorna Observable que emite cuando el usuario completa el flujo.\n   *\n   * @param provider - Proveedor OAuth ('google', 'apple', 'microsoft')\n   * @returns Observable que emite OAuthResult o error\n   */\n  startFlow(provider: OAuthProvider): Observable<OAuthResult> {\n    return new Observable(observer => {\n      // Construir URL de inicio\n      const redirectUri = `${window.location.origin}/auth/oauth/callback`;\n      const startUrl = `${this.config.apiUrl}/v2/auth/oauth/${provider}/start?redirect_uri=${encodeURIComponent(redirectUri)}`;\n\n      // Abrir popup centrado\n      const width = 500;\n      const height = 600;\n      const left = window.screenX + (window.outerWidth - width) / 2;\n      const top = window.screenY + (window.outerHeight - height) / 2;\n      const features = `width=${width},height=${height},left=${left},top=${top},popup=yes`;\n\n      this.popup = window.open(startUrl, 'oauth', features);\n\n      if (!this.popup) {\n        observer.error({\n          code: 'POPUP_BLOCKED',\n          message: 'El navegador bloqueó la ventana emergente. Por favor, permite popups para este sitio.',\n        } as OAuthError);\n        return () => {};\n      }\n\n      // Escuchar mensajes del popup\n      this.messageHandler = (event: MessageEvent) => {\n        // Validar origen\n        if (event.origin !== window.location.origin) {\n          return;\n        }\n\n        // Validar tipo de mensaje\n        const data = event.data as OAuthCallbackData;\n        if (data?.type !== 'oauth-callback') {\n          return;\n        }\n\n        // Limpiar\n        this.cleanup();\n\n        // Emitir resultado dentro de NgZone para trigger change detection\n        this.ngZone.run(() => {\n          if (data.error) {\n            observer.error(data.error);\n          } else if (data.tokens) {\n            observer.next(data.tokens);\n            observer.complete();\n          } else {\n            observer.error({\n              code: 'INVALID_RESPONSE',\n              message: 'Respuesta inválida del servidor de autenticación',\n            } as OAuthError);\n          }\n        });\n      };\n\n      window.addEventListener('message', this.messageHandler);\n\n      // Verificar si popup se cierra - revisar localStorage como fallback (COOP workaround)\n      this.checkClosedInterval = setInterval(() => {\n        if (this.popup?.closed) {\n          this.cleanup();\n\n          // Intentar leer de localStorage (fallback para COOP)\n          this.ngZone.run(() => {\n            const storedData = this.checkLocalStorageFallback();\n            if (storedData) {\n              if (storedData.error) {\n                observer.error(storedData.error);\n              } else if (storedData.tokens) {\n                console.log('[OAuthService] Retrieved tokens from localStorage fallback');\n                observer.next(storedData.tokens);\n                observer.complete();\n              } else {\n                observer.error({\n                  code: 'INVALID_RESPONSE',\n                  message: 'Respuesta inválida del servidor de autenticación',\n                } as OAuthError);\n              }\n            } else {\n              observer.error({\n                code: 'POPUP_CLOSED',\n                message: 'Se cerró la ventana de autenticación',\n              } as OAuthError);\n            }\n          });\n        }\n      }, 500);\n\n      // Cleanup cuando el observable se destruye\n      return () => this.cleanup();\n    });\n  }\n\n  /**\n   * Inicia flujo de linking para vincular un proveedor adicional.\n   * Requiere que el usuario esté autenticado.\n   *\n   * @param provider - Proveedor OAuth a vincular\n   * @returns Observable que emite cuando se completa el linking\n   */\n  startLinkFlow(provider: OAuthProvider): Observable<OAuthResult> {\n    return new Observable(observer => {\n      const redirectUri = `${window.location.origin}/auth/oauth/callback`;\n      const startUrl = `${this.config.apiUrl}/v2/auth/oauth/link/${provider}/start?redirect_uri=${encodeURIComponent(redirectUri)}`;\n\n      const width = 500;\n      const height = 600;\n      const left = window.screenX + (window.outerWidth - width) / 2;\n      const top = window.screenY + (window.outerHeight - height) / 2;\n      const features = `width=${width},height=${height},left=${left},top=${top},popup=yes`;\n\n      this.popup = window.open(startUrl, 'oauth-link', features);\n\n      if (!this.popup) {\n        observer.error({\n          code: 'POPUP_BLOCKED',\n          message: 'El navegador bloqueó la ventana emergente',\n        } as OAuthError);\n        return () => {}; // cleanup function\n      }\n\n      this.messageHandler = (event: MessageEvent) => {\n        if (event.origin !== window.location.origin) return;\n\n        const data = event.data as OAuthCallbackData;\n        if (data?.type !== 'oauth-callback') return;\n\n        this.cleanup();\n\n        this.ngZone.run(() => {\n          if (data.error) {\n            observer.error(data.error);\n          } else {\n            observer.next(data.tokens || {} as OAuthResult);\n            observer.complete();\n          }\n        });\n      };\n\n      window.addEventListener('message', this.messageHandler);\n\n      this.checkClosedInterval = setInterval(() => {\n        if (this.popup?.closed) {\n          this.cleanup();\n          this.ngZone.run(() => {\n            observer.error({\n              code: 'POPUP_CLOSED',\n              message: 'Se cerró la ventana de autenticación',\n            } as OAuthError);\n          });\n        }\n      }, 500);\n\n      return () => this.cleanup();\n    });\n  }\n\n  /**\n   * Obtiene los proveedores OAuth vinculados al usuario.\n   */\n  getLinkedProviders(): Observable<LinkedProvider[]> {\n    return this.http\n      .get<{ providers: LinkedProvider[] }>(`${this.config.apiUrl}/v2/auth/oauth/providers`)\n      .pipe(\n        catchError(error => throwError(() => ({\n          code: error.error?.code || 'FETCH_ERROR',\n          message: error.error?.message || 'Error al obtener proveedores vinculados',\n        } as OAuthError)))\n      ) as unknown as Observable<LinkedProvider[]>;\n  }\n\n  /**\n   * Desvincula un proveedor OAuth.\n   */\n  unlinkProvider(provider: OAuthProvider): Observable<{ success: boolean }> {\n    return this.http\n      .post<{ success: boolean }>(`${this.config.apiUrl}/v2/auth/oauth/unlink`, { provider })\n      .pipe(\n        catchError(error => throwError(() => ({\n          code: error.error?.code || 'UNLINK_ERROR',\n          message: error.error?.message || 'Error al desvincular proveedor',\n        } as OAuthError)))\n      );\n  }\n\n  /**\n   * Establece contraseña para usuarios que solo tienen OAuth.\n   */\n  setPassword(password: string): Observable<{ success: boolean }> {\n    return this.http\n      .post<{ success: boolean }>(`${this.config.apiUrl}/v2/auth/oauth/set-password`, { password })\n      .pipe(\n        catchError(error => throwError(() => ({\n          code: error.error?.code || 'SET_PASSWORD_ERROR',\n          message: error.error?.message || 'Error al establecer contraseña',\n        } as OAuthError)))\n      );\n  }\n\n  /**\n   * Verifica si el usuario tiene contraseña establecida.\n   */\n  hasPassword(): Observable<HasPasswordResponse> {\n    return this.http\n      .get<HasPasswordResponse>(`${this.config.apiUrl}/v2/auth/oauth/has-password`)\n      .pipe(\n        catchError(error => throwError(() => ({\n          code: error.error?.code || 'CHECK_PASSWORD_ERROR',\n          message: error.error?.message || 'Error al verificar contraseña',\n        } as OAuthError)))\n      );\n  }\n\n  /**\n   * Revisa localStorage por datos de callback OAuth (fallback para COOP).\n   * Solo acepta datos recientes (últimos 30 segundos).\n   */\n  private checkLocalStorageFallback(): OAuthCallbackData | null {\n    try {\n      const timestamp = localStorage.getItem('oauth_callback_timestamp');\n      const dataStr = localStorage.getItem('oauth_callback_data');\n\n      if (!timestamp || !dataStr) {\n        return null;\n      }\n\n      // Solo aceptar datos de los últimos 30 segundos\n      const age = Date.now() - parseInt(timestamp, 10);\n      if (age > 30000) {\n        console.log('[OAuthService] localStorage data too old, ignoring');\n        this.clearLocalStorageFallback();\n        return null;\n      }\n\n      const data = JSON.parse(dataStr) as OAuthCallbackData;\n      this.clearLocalStorageFallback();\n      return data;\n    } catch (e) {\n      console.warn('[OAuthService] Error reading localStorage fallback:', e);\n      return null;\n    }\n  }\n\n  /**\n   * Limpia datos de fallback de localStorage.\n   */\n  private clearLocalStorageFallback(): void {\n    try {\n      localStorage.removeItem('oauth_callback_data');\n      localStorage.removeItem('oauth_callback_timestamp');\n    } catch {\n      // Ignorar errores de limpieza\n    }\n  }\n\n  /**\n   * Limpia recursos del popup.\n   */\n  private cleanup(): void {\n    if (this.messageHandler) {\n      window.removeEventListener('message', this.messageHandler);\n      this.messageHandler = null;\n    }\n\n    if (this.checkClosedInterval) {\n      clearInterval(this.checkClosedInterval);\n      this.checkClosedInterval = null;\n    }\n\n    if (this.popup && !this.popup.closed) {\n      this.popup.close();\n    }\n    this.popup = null;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oauth.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/oauth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, NgZone } from '@angular/core';\nimport { Observable, Subject, throwError } from 'rxjs';\nimport { VALTECH_AUTH_CONFIG } from './config';\nimport {\n  ValtechAuthConfig,\n  OAuthProvider,\n  OAuthResult,\n  OAuthError,\n  OAuthCallbackData,\n  LinkedProvider,\n  HasPasswordResponse,\n} from './types';\nimport { HttpClient } from '@angular/common/http';\nimport { catchError } from 'rxjs/operators';\n\n/**\n * Servicio de OAuth para login social.\n *\n * Implementa flujo OAuth server-side con popup:\n * 1. Frontend abre popup hacia backend\n * 2. Backend redirige a provider (Google, Apple, Microsoft)\n * 3. Usuario autoriza\n * 4. Backend intercambia code, genera JWT, redirige con tokens\n * 5. Popup envía tokens a ventana padre via postMessage\n *\n * @example\n * ```typescript\n * import { OAuthService, AuthService } from 'valtech-components';\n *\n * @Component({...})\n * export class LoginComponent {\n *   private oauth = inject(OAuthService);\n *   private auth = inject(AuthService);\n *\n *   async loginWithGoogle() {\n *     this.oauth.startFlow('google').subscribe({\n *       next: (result) => {\n *         // Tokens recibidos, guardar en auth state\n *         this.auth.handleOAuthSuccess(result);\n *         this.router.navigate(['/']);\n *       },\n *       error: (error) => {\n *         console.error('OAuth failed:', error);\n *       }\n *     });\n *   }\n * }\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class OAuthService {\n  private popup: Window | null = null;\n  private messageHandler: ((event: MessageEvent) => void) | null = null;\n  private checkClosedInterval: ReturnType<typeof setInterval> | null = null;\n\n  constructor(\n    @Inject(VALTECH_AUTH_CONFIG) private config: ValtechAuthConfig,\n    private http: HttpClient,\n    private ngZone: NgZone\n  ) {}\n\n  /**\n   * Inicia flujo OAuth en popup.\n   * Retorna Observable que emite cuando el usuario completa el flujo.\n   *\n   * @param provider - Proveedor OAuth ('google', 'apple', 'microsoft')\n   * @returns Observable que emite OAuthResult o error\n   */\n  startFlow(provider: OAuthProvider): Observable<OAuthResult> {\n    return new Observable(observer => {\n      // Construir URL de inicio\n      const redirectUri = `${window.location.origin}/auth/oauth/callback`;\n      const startUrl = `${this.config.apiUrl}/v2/auth/oauth/${provider}/start?redirect_uri=${encodeURIComponent(redirectUri)}`;\n\n      // Abrir popup centrado\n      const width = 500;\n      const height = 600;\n      const left = window.screenX + (window.outerWidth - width) / 2;\n      const top = window.screenY + (window.outerHeight - height) / 2;\n      const features = `width=${width},height=${height},left=${left},top=${top},popup=yes`;\n\n      this.popup = window.open(startUrl, 'oauth', features);\n\n      if (!this.popup) {\n        observer.error({\n          code: 'POPUP_BLOCKED',\n          message: 'El navegador bloqueó la ventana emergente. Por favor, permite popups para este sitio.',\n        } as OAuthError);\n        return () => {};\n      }\n\n      // Escuchar mensajes del popup\n      this.messageHandler = (event: MessageEvent) => {\n        // Validar origen\n        if (event.origin !== window.location.origin) {\n          return;\n        }\n\n        // Validar tipo de mensaje\n        const data = event.data as OAuthCallbackData;\n        if (data?.type !== 'oauth-callback') {\n          return;\n        }\n\n        // Limpiar\n        this.cleanup();\n\n        // Emitir resultado dentro de NgZone para trigger change detection\n        this.ngZone.run(() => {\n          if (data.error) {\n            observer.error(data.error);\n          } else if (data.tokens) {\n            observer.next(data.tokens);\n            observer.complete();\n          } else {\n            observer.error({\n              code: 'INVALID_RESPONSE',\n              message: 'Respuesta inválida del servidor de autenticación',\n            } as OAuthError);\n          }\n        });\n      };\n\n      window.addEventListener('message', this.messageHandler);\n\n      // Polling de localStorage (COOP workaround - no podemos detectar popup.closed)\n      // También verifica si el popup se cerró manualmente\n      this.checkClosedInterval = setInterval(() => {\n        // Primero verificar localStorage (funciona aunque COOP bloquee todo)\n        const storedData = this.checkLocalStorageFallback();\n        if (storedData) {\n          this.cleanup();\n          this.ngZone.run(() => {\n            if (storedData.error) {\n              observer.error(storedData.error);\n            } else if (storedData.tokens) {\n              console.log('[OAuthService] Retrieved tokens from localStorage fallback');\n              observer.next(storedData.tokens);\n              observer.complete();\n            } else {\n              observer.error({\n                code: 'INVALID_RESPONSE',\n                message: 'Respuesta inválida del servidor de autenticación',\n              } as OAuthError);\n            }\n          });\n          return;\n        }\n\n        // Intentar verificar si popup se cerró (puede fallar por COOP)\n        try {\n          if (this.popup?.closed) {\n            this.cleanup();\n            this.ngZone.run(() => {\n              observer.error({\n                code: 'POPUP_CLOSED',\n                message: 'Se cerró la ventana de autenticación',\n              } as OAuthError);\n            });\n          }\n        } catch {\n          // COOP bloquea acceso a popup.closed - ignorar y seguir con polling\n        }\n      }, 300);\n\n      // Cleanup cuando el observable se destruye\n      return () => this.cleanup();\n    });\n  }\n\n  /**\n   * Inicia flujo de linking para vincular un proveedor adicional.\n   * Requiere que el usuario esté autenticado.\n   *\n   * @param provider - Proveedor OAuth a vincular\n   * @returns Observable que emite cuando se completa el linking\n   */\n  startLinkFlow(provider: OAuthProvider): Observable<OAuthResult> {\n    return new Observable(observer => {\n      const redirectUri = `${window.location.origin}/auth/oauth/callback`;\n      const startUrl = `${this.config.apiUrl}/v2/auth/oauth/link/${provider}/start?redirect_uri=${encodeURIComponent(redirectUri)}`;\n\n      const width = 500;\n      const height = 600;\n      const left = window.screenX + (window.outerWidth - width) / 2;\n      const top = window.screenY + (window.outerHeight - height) / 2;\n      const features = `width=${width},height=${height},left=${left},top=${top},popup=yes`;\n\n      this.popup = window.open(startUrl, 'oauth-link', features);\n\n      if (!this.popup) {\n        observer.error({\n          code: 'POPUP_BLOCKED',\n          message: 'El navegador bloqueó la ventana emergente',\n        } as OAuthError);\n        return () => {}; // cleanup function\n      }\n\n      this.messageHandler = (event: MessageEvent) => {\n        if (event.origin !== window.location.origin) return;\n\n        const data = event.data as OAuthCallbackData;\n        if (data?.type !== 'oauth-callback') return;\n\n        this.cleanup();\n\n        this.ngZone.run(() => {\n          if (data.error) {\n            observer.error(data.error);\n          } else {\n            observer.next(data.tokens || {} as OAuthResult);\n            observer.complete();\n          }\n        });\n      };\n\n      window.addEventListener('message', this.messageHandler);\n\n      this.checkClosedInterval = setInterval(() => {\n        if (this.popup?.closed) {\n          this.cleanup();\n          this.ngZone.run(() => {\n            observer.error({\n              code: 'POPUP_CLOSED',\n              message: 'Se cerró la ventana de autenticación',\n            } as OAuthError);\n          });\n        }\n      }, 500);\n\n      return () => this.cleanup();\n    });\n  }\n\n  /**\n   * Obtiene los proveedores OAuth vinculados al usuario.\n   */\n  getLinkedProviders(): Observable<LinkedProvider[]> {\n    return this.http\n      .get<{ providers: LinkedProvider[] }>(`${this.config.apiUrl}/v2/auth/oauth/providers`)\n      .pipe(\n        catchError(error => throwError(() => ({\n          code: error.error?.code || 'FETCH_ERROR',\n          message: error.error?.message || 'Error al obtener proveedores vinculados',\n        } as OAuthError)))\n      ) as unknown as Observable<LinkedProvider[]>;\n  }\n\n  /**\n   * Desvincula un proveedor OAuth.\n   */\n  unlinkProvider(provider: OAuthProvider): Observable<{ success: boolean }> {\n    return this.http\n      .post<{ success: boolean }>(`${this.config.apiUrl}/v2/auth/oauth/unlink`, { provider })\n      .pipe(\n        catchError(error => throwError(() => ({\n          code: error.error?.code || 'UNLINK_ERROR',\n          message: error.error?.message || 'Error al desvincular proveedor',\n        } as OAuthError)))\n      );\n  }\n\n  /**\n   * Establece contraseña para usuarios que solo tienen OAuth.\n   */\n  setPassword(password: string): Observable<{ success: boolean }> {\n    return this.http\n      .post<{ success: boolean }>(`${this.config.apiUrl}/v2/auth/oauth/set-password`, { password })\n      .pipe(\n        catchError(error => throwError(() => ({\n          code: error.error?.code || 'SET_PASSWORD_ERROR',\n          message: error.error?.message || 'Error al establecer contraseña',\n        } as OAuthError)))\n      );\n  }\n\n  /**\n   * Verifica si el usuario tiene contraseña establecida.\n   */\n  hasPassword(): Observable<HasPasswordResponse> {\n    return this.http\n      .get<HasPasswordResponse>(`${this.config.apiUrl}/v2/auth/oauth/has-password`)\n      .pipe(\n        catchError(error => throwError(() => ({\n          code: error.error?.code || 'CHECK_PASSWORD_ERROR',\n          message: error.error?.message || 'Error al verificar contraseña',\n        } as OAuthError)))\n      );\n  }\n\n  /**\n   * Revisa localStorage por datos de callback OAuth (fallback para COOP).\n   * Solo acepta datos recientes (últimos 30 segundos).\n   */\n  private checkLocalStorageFallback(): OAuthCallbackData | null {\n    try {\n      const timestamp = localStorage.getItem('oauth_callback_timestamp');\n      const dataStr = localStorage.getItem('oauth_callback_data');\n\n      if (!timestamp || !dataStr) {\n        return null;\n      }\n\n      // Solo aceptar datos de los últimos 30 segundos\n      const age = Date.now() - parseInt(timestamp, 10);\n      if (age > 30000) {\n        console.log('[OAuthService] localStorage data too old, ignoring');\n        this.clearLocalStorageFallback();\n        return null;\n      }\n\n      const data = JSON.parse(dataStr) as OAuthCallbackData;\n      this.clearLocalStorageFallback();\n      return data;\n    } catch (e) {\n      console.warn('[OAuthService] Error reading localStorage fallback:', e);\n      return null;\n    }\n  }\n\n  /**\n   * Limpia datos de fallback de localStorage.\n   */\n  private clearLocalStorageFallback(): void {\n    try {\n      localStorage.removeItem('oauth_callback_data');\n      localStorage.removeItem('oauth_callback_timestamp');\n    } catch {\n      // Ignorar errores de limpieza\n    }\n  }\n\n  /**\n   * Limpia recursos del popup.\n   */\n  private cleanup(): void {\n    if (this.messageHandler) {\n      window.removeEventListener('message', this.messageHandler);\n      this.messageHandler = null;\n    }\n\n    if (this.checkClosedInterval) {\n      clearInterval(this.checkClosedInterval);\n      this.checkClosedInterval = null;\n    }\n\n    if (this.popup && !this.popup.closed) {\n      this.popup.close();\n    }\n    this.popup = null;\n  }\n}\n"]}