@nauth-toolkit/client-angular 0.1.56 → 0.1.58

package/esm2022/lib/auth.guard.mjs

@@ -0,0 +1,83 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { AuthService } from '../ngmodule/auth.service';
+/**
+ * Functional route guard for authentication (Angular 17+).
+ *
+ * Protects routes by checking if user is authenticated.
+ * Redirects to login page if not authenticated.
+ *
+ * @param redirectTo - Path to redirect to if not authenticated (default: '/login')
+ * @returns CanActivateFn guard function
+ *
+ * @example
+ * ```typescript
+ * // In route configuration
+ * const routes: Routes = [
+ *   {
+ *     path: 'home',
+ *     component: HomeComponent,
+ *     canActivate: [authGuard()]
+ *   },
+ *   {
+ *     path: 'admin',
+ *     component: AdminComponent,
+ *     canActivate: [authGuard('/admin/login')]
+ *   }
+ * ];
+ * ```
+ */
+export function authGuard(redirectTo = '/login') {
+    return () => {
+        const auth = inject(AuthService);
+        const router = inject(Router);
+        if (auth.isAuthenticated()) {
+            return true;
+        }
+        return router.createUrlTree([redirectTo]);
+    };
+}
+/**
+ * Class-based authentication guard for NgModule compatibility.
+ *
+ * @example
+ * ```typescript
+ * // In route configuration (NgModule)
+ * const routes: Routes = [
+ *   {
+ *     path: 'home',
+ *     component: HomeComponent,
+ *     canActivate: [AuthGuard]
+ *   }
+ * ];
+ *
+ * // In module providers
+ * @NgModule({
+ *   providers: [AuthGuard]
+ * })
+ * ```
+ */
+export class AuthGuard {
+    auth;
+    router;
+    /**
+     * @param auth - Authentication service
+     * @param router - Angular router
+     */
+    constructor(auth, router) {
+        this.auth = auth;
+        this.router = router;
+    }
+    /**
+     * Check if route can be activated.
+     *
+     * @returns True if authenticated, otherwise redirects to login
+     */
+    canActivate() {
+        if (this.auth.isAuthenticated()) {
+            return true;
+        }
+        return this.router.createUrlTree(['/login']);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth.interceptor.mjs

@@ -0,0 +1,158 @@
+import { inject, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { Router } from '@angular/router';
+import { catchError, switchMap, throwError, filter, take, BehaviorSubject, from } from 'rxjs';
+import { NAUTH_CLIENT_CONFIG } from '../ngmodule/tokens';
+import { AuthService } from '../ngmodule/auth.service';
+/**
+ * Refresh state management.
+ * BehaviorSubject pattern is the industry-standard for token refresh.
+ */
+let isRefreshing = false;
+const refreshTokenSubject = new BehaviorSubject(null);
+/**
+ * Track retried requests to prevent infinite loops.
+ */
+const retriedRequests = new WeakSet();
+/**
+ * Get CSRF token from cookie.
+ */
+function getCsrfToken(cookieName) {
+    if (typeof document === 'undefined')
+        return null;
+    const match = document.cookie.match(new RegExp(`(^| )${cookieName}=([^;]+)`));
+    return match ? decodeURIComponent(match[2]) : null;
+}
+/**
+ * Angular HTTP interceptor for nauth-toolkit.
+ *
+ * Handles:
+ * - Cookies mode: withCredentials + CSRF tokens + refresh via POST
+ * - JSON mode: refresh via SDK, retry with new token
+ */
+export const authInterceptor = (req, next) => {
+    const config = inject(NAUTH_CLIENT_CONFIG);
+    const http = inject(HttpClient);
+    const authService = inject(AuthService);
+    const platformId = inject(PLATFORM_ID);
+    const router = inject(Router);
+    const isBrowser = isPlatformBrowser(platformId);
+    if (!isBrowser) {
+        return next(req);
+    }
+    const tokenDelivery = config.tokenDelivery;
+    const baseUrl = config.baseUrl;
+    const endpoints = config.endpoints ?? {};
+    const refreshPath = endpoints.refresh ?? '/refresh';
+    const loginPath = endpoints.login ?? '/login';
+    const signupPath = endpoints.signup ?? '/signup';
+    const socialExchangePath = endpoints.socialExchange ?? '/social/exchange';
+    const refreshUrl = `${baseUrl}${refreshPath}`;
+    const isAuthApiRequest = req.url.includes(baseUrl);
+    const isRefreshEndpoint = req.url.includes(refreshPath);
+    const isPublicEndpoint = req.url.includes(loginPath) || req.url.includes(signupPath) || req.url.includes(socialExchangePath);
+    // Build request with credentials (cookies mode only)
+    let authReq = req;
+    if (tokenDelivery === 'cookies') {
+        authReq = authReq.clone({ withCredentials: true });
+        if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(req.method)) {
+            const csrfCookieName = config.csrf?.cookieName ?? 'nauth_csrf_token';
+            const csrfHeaderName = config.csrf?.headerName ?? 'x-csrf-token';
+            const csrfToken = getCsrfToken(csrfCookieName);
+            if (csrfToken) {
+                authReq = authReq.clone({ setHeaders: { [csrfHeaderName]: csrfToken } });
+            }
+        }
+    }
+    return next(authReq).pipe(catchError((error) => {
+        const shouldHandle = error instanceof HttpErrorResponse &&
+            error.status === 401 &&
+            isAuthApiRequest &&
+            !isRefreshEndpoint &&
+            !isPublicEndpoint &&
+            !retriedRequests.has(req);
+        if (!shouldHandle) {
+            return throwError(() => error);
+        }
+        if (config.debug) {
+            console.warn('[nauth-interceptor] 401 detected:', req.url);
+        }
+        if (!isRefreshing) {
+            isRefreshing = true;
+            refreshTokenSubject.next(null);
+            if (config.debug) {
+                console.warn('[nauth-interceptor] Starting refresh...');
+            }
+            // Refresh based on mode
+            const refresh$ = tokenDelivery === 'cookies'
+                ? http.post(refreshUrl, {}, { withCredentials: true })
+                : from(authService.refresh());
+            return refresh$.pipe(switchMap((response) => {
+                if (config.debug) {
+                    console.warn('[nauth-interceptor] Refresh successful');
+                }
+                isRefreshing = false;
+                // Get new token (JSON mode) or signal success (cookies mode)
+                const newToken = 'accessToken' in response ? response.accessToken : 'success';
+                refreshTokenSubject.next(newToken ?? 'success');
+                // Build retry request
+                const retryReq = buildRetryRequest(authReq, tokenDelivery, newToken);
+                retriedRequests.add(retryReq);
+                if (config.debug) {
+                    console.warn('[nauth-interceptor] Retrying:', req.url);
+                }
+                return next(retryReq);
+            }), catchError((err) => {
+                if (config.debug) {
+                    console.error('[nauth-interceptor] Refresh failed:', err);
+                }
+                isRefreshing = false;
+                refreshTokenSubject.next(null);
+                // Handle session expiration - redirect to configured URL
+                if (config.redirects?.sessionExpired) {
+                    router.navigateByUrl(config.redirects.sessionExpired).catch((navError) => {
+                        if (config.debug) {
+                            console.error('[nauth-interceptor] Navigation failed:', navError);
+                        }
+                    });
+                }
+                return throwError(() => err);
+            }));
+        }
+        else {
+            // Wait for ongoing refresh
+            if (config.debug) {
+                console.warn('[nauth-interceptor] Waiting for refresh...');
+            }
+            return refreshTokenSubject.pipe(filter((token) => token !== null), take(1), switchMap((token) => {
+                if (config.debug) {
+                    console.warn('[nauth-interceptor] Refresh done, retrying:', req.url);
+                }
+                const retryReq = buildRetryRequest(authReq, tokenDelivery, token);
+                retriedRequests.add(retryReq);
+                return next(retryReq);
+            }));
+        }
+    }));
+};
+/**
+ * Build retry request with appropriate auth.
+ */
+function buildRetryRequest(originalReq, tokenDelivery, newToken) {
+    if (tokenDelivery === 'json' && newToken && newToken !== 'success') {
+        return originalReq.clone({
+            setHeaders: { Authorization: `Bearer ${newToken}` },
+        });
+    }
+    return originalReq.clone();
+}
+/**
+ * Class-based interceptor for NgModule compatibility.
+ */
+export class AuthInterceptor {
+    intercept(req, next) {
+        return authInterceptor(req, next);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.interceptor.js","sourceRoot":"","sources":["../../../src/lib/auth.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, PLATFORM_ID } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { HttpHandlerFn, HttpInterceptorFn, HttpRequest, HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { Router } from '@angular/router';\nimport { catchError, switchMap, throwError, filter, take, BehaviorSubject, from } from 'rxjs';\nimport { NAUTH_CLIENT_CONFIG } from '../ngmodule/tokens';\nimport { AuthService } from '../ngmodule/auth.service';\n\n/**\n * Refresh state management.\n * BehaviorSubject pattern is the industry-standard for token refresh.\n */\nlet isRefreshing = false;\nconst refreshTokenSubject = new BehaviorSubject<string | null>(null);\n\n/**\n * Track retried requests to prevent infinite loops.\n */\nconst retriedRequests = new WeakSet<HttpRequest<unknown>>();\n\n/**\n * Get CSRF token from cookie.\n */\nfunction getCsrfToken(cookieName: string): string | null {\n  if (typeof document === 'undefined') return null;\n  const match = document.cookie.match(new RegExp(`(^| )${cookieName}=([^;]+)`));\n  return match ? decodeURIComponent(match[2]) : null;\n}\n\n/**\n * Angular HTTP interceptor for nauth-toolkit.\n *\n * Handles:\n * - Cookies mode: withCredentials + CSRF tokens + refresh via POST\n * - JSON mode: refresh via SDK, retry with new token\n */\nexport const authInterceptor: HttpInterceptorFn = (req: HttpRequest<unknown>, next: HttpHandlerFn) => {\n  const config = inject(NAUTH_CLIENT_CONFIG);\n  const http = inject(HttpClient);\n  const authService = inject(AuthService);\n  const platformId = inject(PLATFORM_ID);\n  const router = inject(Router);\n  const isBrowser = isPlatformBrowser(platformId);\n\n  if (!isBrowser) {\n    return next(req);\n  }\n\n  const tokenDelivery = config.tokenDelivery;\n  const baseUrl = config.baseUrl;\n  const endpoints = config.endpoints ?? {};\n  const refreshPath = endpoints.refresh ?? '/refresh';\n  const loginPath = endpoints.login ?? '/login';\n  const signupPath = endpoints.signup ?? '/signup';\n  const socialExchangePath = endpoints.socialExchange ?? '/social/exchange';\n  const refreshUrl = `${baseUrl}${refreshPath}`;\n\n  const isAuthApiRequest = req.url.includes(baseUrl);\n  const isRefreshEndpoint = req.url.includes(refreshPath);\n  const isPublicEndpoint =\n    req.url.includes(loginPath) || req.url.includes(signupPath) || req.url.includes(socialExchangePath);\n\n  // Build request with credentials (cookies mode only)\n  let authReq = req;\n  if (tokenDelivery === 'cookies') {\n    authReq = authReq.clone({ withCredentials: true });\n\n    if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(req.method)) {\n      const csrfCookieName = config.csrf?.cookieName ?? 'nauth_csrf_token';\n      const csrfHeaderName = config.csrf?.headerName ?? 'x-csrf-token';\n      const csrfToken = getCsrfToken(csrfCookieName);\n      if (csrfToken) {\n        authReq = authReq.clone({ setHeaders: { [csrfHeaderName]: csrfToken } });\n      }\n    }\n  }\n\n  return next(authReq).pipe(\n    catchError((error: unknown) => {\n      const shouldHandle =\n        error instanceof HttpErrorResponse &&\n        error.status === 401 &&\n        isAuthApiRequest &&\n        !isRefreshEndpoint &&\n        !isPublicEndpoint &&\n        !retriedRequests.has(req);\n\n      if (!shouldHandle) {\n        return throwError(() => error);\n      }\n\n      if (config.debug) {\n        console.warn('[nauth-interceptor] 401 detected:', req.url);\n      }\n\n      if (!isRefreshing) {\n        isRefreshing = true;\n        refreshTokenSubject.next(null);\n\n        if (config.debug) {\n          console.warn('[nauth-interceptor] Starting refresh...');\n        }\n\n        // Refresh based on mode\n        const refresh$ =\n          tokenDelivery === 'cookies'\n            ? http.post<{ accessToken?: string }>(refreshUrl, {}, { withCredentials: true })\n            : from(authService.refresh());\n\n        return refresh$.pipe(\n          switchMap((response) => {\n            if (config.debug) {\n              console.warn('[nauth-interceptor] Refresh successful');\n            }\n            isRefreshing = false;\n\n            // Get new token (JSON mode) or signal success (cookies mode)\n            const newToken = 'accessToken' in response ? response.accessToken : 'success';\n            refreshTokenSubject.next(newToken ?? 'success');\n\n            // Build retry request\n            const retryReq = buildRetryRequest(authReq, tokenDelivery, newToken);\n            retriedRequests.add(retryReq);\n\n            if (config.debug) {\n              console.warn('[nauth-interceptor] Retrying:', req.url);\n            }\n            return next(retryReq);\n          }),\n          catchError((err) => {\n            if (config.debug) {\n              console.error('[nauth-interceptor] Refresh failed:', err);\n            }\n            isRefreshing = false;\n            refreshTokenSubject.next(null);\n\n            // Handle session expiration - redirect to configured URL\n            if (config.redirects?.sessionExpired) {\n              router.navigateByUrl(config.redirects.sessionExpired).catch((navError) => {\n                if (config.debug) {\n                  console.error('[nauth-interceptor] Navigation failed:', navError);\n                }\n              });\n            }\n\n            return throwError(() => err);\n          }),\n        );\n      } else {\n        // Wait for ongoing refresh\n        if (config.debug) {\n          console.warn('[nauth-interceptor] Waiting for refresh...');\n        }\n        return refreshTokenSubject.pipe(\n          filter((token): token is string => token !== null),\n          take(1),\n          switchMap((token) => {\n            if (config.debug) {\n              console.warn('[nauth-interceptor] Refresh done, retrying:', req.url);\n            }\n            const retryReq = buildRetryRequest(authReq, tokenDelivery, token);\n            retriedRequests.add(retryReq);\n            return next(retryReq);\n          }),\n        );\n      }\n    }),\n  );\n};\n\n/**\n * Build retry request with appropriate auth.\n */\nfunction buildRetryRequest(\n  originalReq: HttpRequest<unknown>,\n  tokenDelivery: string,\n  newToken?: string,\n): HttpRequest<unknown> {\n  if (tokenDelivery === 'json' && newToken && newToken !== 'success') {\n    return originalReq.clone({\n      setHeaders: { Authorization: `Bearer ${newToken}` },\n    });\n  }\n  return originalReq.clone();\n}\n\n/**\n * Class-based interceptor for NgModule compatibility.\n */\nexport class AuthInterceptor {\n  intercept(req: HttpRequest<unknown>, next: HttpHandlerFn) {\n    return authInterceptor(req, next);\n  }\n}\n"]}

package/esm2022/lib/social-redirect-callback.guard.mjs

@@ -0,0 +1,81 @@
+import { inject, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { AuthService } from '../ngmodule/auth.service';
+import { NAUTH_CLIENT_CONFIG } from '../ngmodule/tokens';
+/**
+ * Social redirect callback route guard.
+ *
+ * This guard supports the redirect-first social flow where the backend redirects
+ * back to the frontend with:
+ * - `appState` (always optional)
+ * - `exchangeToken` (present for json/hybrid flows, and for cookie flows that return a challenge)
+ * - `error` / `error_description` (provider errors)
+ *
+ * Behavior:
+ * - If `exchangeToken` exists: exchanges it via backend and redirects to success or challenge routes.
+ * - If no `exchangeToken`: treat as cookie-success path and redirect to success route.
+ * - If `error` exists: redirects to oauthError route.
+ *
+ * @example
+ * ```typescript
+ * import { socialRedirectCallbackGuard } from '@nauth-toolkit/client/angular';
+ *
+ * export const routes: Routes = [
+ *   { path: 'auth/callback', canActivate: [socialRedirectCallbackGuard], component: CallbackComponent },
+ * ];
+ * ```
+ */
+export const socialRedirectCallbackGuard = async () => {
+    const auth = inject(AuthService);
+    const config = inject(NAUTH_CLIENT_CONFIG);
+    const platformId = inject(PLATFORM_ID);
+    const isBrowser = isPlatformBrowser(platformId);
+    if (!isBrowser) {
+        return false;
+    }
+    const params = new URLSearchParams(window.location.search);
+    const error = params.get('error');
+    const exchangeToken = params.get('exchangeToken');
+    // Provider error: redirect to oauthError
+    if (error) {
+        const errorUrl = config.redirects?.oauthError || '/login';
+        window.location.replace(errorUrl);
+        return false;
+    }
+    // No exchangeToken: cookie success path; redirect to success.
+    //
+    // Note: we do not "activate" the callback route to avoid consumers needing to render a page.
+    if (!exchangeToken) {
+        // ============================================================================
+        // Cookies mode: hydrate user state before redirecting
+        // ============================================================================
+        // WHY: In cookie delivery, the OAuth callback completes via browser redirects, so the frontend
+        // does not receive a JSON AuthResponse to populate the SDK's cached `currentUser`.
+        //
+        // Without this, sync guards (`authGuard`) can immediately redirect to /login because
+        // `currentUser` is still null even though cookies were set successfully.
+        try {
+            await auth.getProfile();
+        }
+        catch {
+            const errorUrl = config.redirects?.oauthError || '/login';
+            window.location.replace(errorUrl);
+            return false;
+        }
+        const successUrl = config.redirects?.success || '/';
+        window.location.replace(successUrl);
+        return false;
+    }
+    // Exchange token and route accordingly
+    const response = await auth.exchangeSocialRedirect(exchangeToken);
+    if (response.challengeName) {
+        const challengeBase = config.redirects?.challengeBase || '/auth/challenge';
+        const challengeRoute = response.challengeName.toLowerCase().replace(/_/g, '-');
+        window.location.replace(`${challengeBase}/${challengeRoute}`);
+        return false;
+    }
+    const successUrl = config.redirects?.success || '/';
+    window.location.replace(successUrl);
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/nauth-toolkit-client-angular.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF1dGgtdG9vbGtpdC1jbGllbnQtYW5ndWxhci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9uYXV0aC10b29sa2l0LWNsaWVudC1hbmd1bGFyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/ngmodule/auth.interceptor.class.mjs

@@ -0,0 +1,109 @@
+import { Injectable, Inject } from '@angular/core';
+import { catchError, switchMap, throwError, filter, take, BehaviorSubject, from } from 'rxjs';
+import { NAUTH_CLIENT_CONFIG } from './tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./auth.service";
+import * as i3 from "@angular/router";
+/**
+ * Refresh state management.
+ */
+let isRefreshing = false;
+const refreshTokenSubject = new BehaviorSubject(null);
+const retriedRequests = new WeakSet();
+/**
+ * Get CSRF token from cookie.
+ */
+function getCsrfToken(cookieName) {
+    if (typeof document === 'undefined')
+        return null;
+    const match = document.cookie.match(new RegExp(`(^| )${cookieName}=([^;]+)`));
+    return match ? decodeURIComponent(match[2]) : null;
+}
+/**
+ * Class-based HTTP interceptor for NgModule apps (Angular < 17).
+ *
+ * For standalone components (Angular 17+), use the functional `authInterceptor` instead.
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * import { HTTP_INTERCEPTORS } from '@angular/common/http';
+ * import { AuthInterceptorClass } from '@nauth-toolkit/client-angular';
+ *
+ * @NgModule({
+ *   providers: [
+ *     { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptorClass, multi: true }
+ *   ]
+ * })
+ * ```
+ */
+export class AuthInterceptorClass {
+    config;
+    http;
+    authService;
+    router;
+    constructor(config, http, authService, router) {
+        this.config = config;
+        this.http = http;
+        this.authService = authService;
+        this.router = router;
+    }
+    intercept(req, next) {
+        const tokenDelivery = this.config.tokenDelivery;
+        const baseUrl = this.config.baseUrl;
+        // ============================================================================
+        // COOKIES MODE: withCredentials + CSRF token
+        // ============================================================================
+        if (tokenDelivery === 'cookies') {
+            let clonedReq = req.clone({ withCredentials: true });
+            // Add CSRF token header if it's a mutating request
+            if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(req.method)) {
+                const csrfToken = getCsrfToken(this.config.csrf?.cookieName || 'XSRF-TOKEN');
+                if (csrfToken) {
+                    clonedReq = clonedReq.clone({
+                        setHeaders: { [this.config.csrf?.headerName || 'X-XSRF-TOKEN']: csrfToken },
+                    });
+                }
+            }
+            return next.handle(clonedReq).pipe(catchError((error) => {
+                if (error.status === 401 && !retriedRequests.has(req)) {
+                    retriedRequests.add(req);
+                    if (!isRefreshing) {
+                        isRefreshing = true;
+                        refreshTokenSubject.next(null);
+                        return from(this.http
+                            .post(`${baseUrl}/refresh`, {}, { withCredentials: true })
+                            .toPromise()).pipe(switchMap(() => {
+                            isRefreshing = false;
+                            refreshTokenSubject.next('refreshed');
+                            return next.handle(clonedReq);
+                        }), catchError((refreshError) => {
+                            isRefreshing = false;
+                            this.authService.logout();
+                            this.router.navigate([this.config.redirects?.sessionExpired || '/login']);
+                            return throwError(() => refreshError);
+                        }));
+                    }
+                    else {
+                        return refreshTokenSubject.pipe(filter((token) => token !== null), take(1), switchMap(() => next.handle(clonedReq)));
+                    }
+                }
+                return throwError(() => error);
+            }));
+        }
+        // ============================================================================
+        // JSON MODE: Delegate to SDK for token handling
+        // ============================================================================
+        return next.handle(req);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthInterceptorClass, deps: [{ token: NAUTH_CLIENT_CONFIG }, { token: i1.HttpClient }, { token: i2.AuthService }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthInterceptorClass });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthInterceptorClass, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NAUTH_CLIENT_CONFIG]
+                }] }, { type: i1.HttpClient }, { type: i2.AuthService }, { type: i3.Router }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.interceptor.class.js","sourceRoot":"","sources":["../../../src/ngmodule/auth.interceptor.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\nimport {\n  HttpInterceptor,\n  HttpRequest,\n  HttpHandler,\n  HttpEvent,\n  HttpClient,\n  HttpErrorResponse,\n} from '@angular/common/http';\nimport { Router } from '@angular/router';\nimport { Observable, catchError, switchMap, throwError, filter, take, BehaviorSubject, from } from 'rxjs';\nimport { NAUTH_CLIENT_CONFIG } from './tokens';\nimport { AuthService } from './auth.service';\nimport { NAuthClientConfig } from '@nauth-toolkit/client';\n\n/**\n * Refresh state management.\n */\nlet isRefreshing = false;\nconst refreshTokenSubject = new BehaviorSubject<string | null>(null);\nconst retriedRequests = new WeakSet<HttpRequest<unknown>>();\n\n/**\n * Get CSRF token from cookie.\n */\nfunction getCsrfToken(cookieName: string): string | null {\n  if (typeof document === 'undefined') return null;\n  const match = document.cookie.match(new RegExp(`(^| )${cookieName}=([^;]+)`));\n  return match ? decodeURIComponent(match[2]) : null;\n}\n\n/**\n * Class-based HTTP interceptor for NgModule apps (Angular < 17).\n *\n * For standalone components (Angular 17+), use the functional `authInterceptor` instead.\n *\n * @example\n * ```typescript\n * // app.module.ts\n * import { HTTP_INTERCEPTORS } from '@angular/common/http';\n * import { AuthInterceptorClass } from '@nauth-toolkit/client-angular';\n *\n * @NgModule({\n *   providers: [\n *     { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptorClass, multi: true }\n *   ]\n * })\n * ```\n */\n@Injectable()\nexport class AuthInterceptorClass implements HttpInterceptor {\n  constructor(\n    @Inject(NAUTH_CLIENT_CONFIG) private readonly config: NAuthClientConfig,\n    private readonly http: HttpClient,\n    private readonly authService: AuthService,\n    private readonly router: Router,\n  ) {}\n\n  intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {\n    const tokenDelivery = this.config.tokenDelivery;\n    const baseUrl = this.config.baseUrl;\n\n    // ============================================================================\n    // COOKIES MODE: withCredentials + CSRF token\n    // ============================================================================\n    if (tokenDelivery === 'cookies') {\n      let clonedReq = req.clone({ withCredentials: true });\n\n      // Add CSRF token header if it's a mutating request\n      if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(req.method)) {\n        const csrfToken = getCsrfToken(this.config.csrf?.cookieName || 'XSRF-TOKEN');\n        if (csrfToken) {\n          clonedReq = clonedReq.clone({\n            setHeaders: { [this.config.csrf?.headerName || 'X-XSRF-TOKEN']: csrfToken },\n          });\n        }\n      }\n\n      return next.handle(clonedReq).pipe(\n        catchError((error: HttpErrorResponse) => {\n          if (error.status === 401 && !retriedRequests.has(req)) {\n            retriedRequests.add(req);\n\n            if (!isRefreshing) {\n              isRefreshing = true;\n              refreshTokenSubject.next(null);\n\n              return from(\n                this.http\n                  .post<{ accessToken?: string }>(`${baseUrl}/refresh`, {}, { withCredentials: true })\n                  .toPromise(),\n              ).pipe(\n                switchMap(() => {\n                  isRefreshing = false;\n                  refreshTokenSubject.next('refreshed');\n                  return next.handle(clonedReq);\n                }),\n                catchError((refreshError) => {\n                  isRefreshing = false;\n                  this.authService.logout();\n                  this.router.navigate([this.config.redirects?.sessionExpired || '/login']);\n                  return throwError(() => refreshError);\n                }),\n              );\n            } else {\n              return refreshTokenSubject.pipe(\n                filter((token) => token !== null),\n                take(1),\n                switchMap(() => next.handle(clonedReq)),\n              );\n            }\n          }\n\n          return throwError(() => error);\n        }),\n      );\n    }\n\n    // ============================================================================\n    // JSON MODE: Delegate to SDK for token handling\n    // ============================================================================\n    return next.handle(req);\n  }\n}\n"]}