@nauth-toolkit/client-angular 0.1.56 → 0.1.57

package/esm2022/ngmodule/http-adapter.mjs

@@ -0,0 +1,81 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { firstValueFrom } from 'rxjs';
+import { NAuthClientError, NAuthErrorCode } from '@nauth-toolkit/client';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * HTTP adapter for Angular using HttpClient.
+ *
+ * This adapter:
+ * - Uses Angular's HttpClient for all requests
+ * - Works with Angular's HTTP interceptors (including authInterceptor)
+ * - Auto-provided via Angular DI (providedIn: 'root')
+ * - Converts HttpClient responses to HttpResponse format
+ * - Converts HttpErrorResponse to NAuthClientError
+ *
+ * Users don't need to configure this manually - it's automatically
+ * injected when using AuthService in Angular apps.
+ *
+ * @example
+ * ```typescript
+ * // Automatic usage (no manual setup needed)
+ * // AuthService automatically injects AngularHttpAdapter
+ * constructor(private auth: AuthService) {}
+ * ```
+ */
+export class AngularHttpAdapter {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Execute HTTP request using Angular's HttpClient.
+     *
+     * @param config - Request configuration
+     * @returns Response with parsed data
+     * @throws NAuthClientError if request fails
+     */
+    async request(config) {
+        try {
+            // Use Angular's HttpClient - goes through ALL interceptors
+            const data = await firstValueFrom(this.http.request(config.method, config.url, {
+                body: config.body,
+                headers: config.headers,
+                withCredentials: config.credentials === 'include',
+                observe: 'body', // Only return body data
+            }));
+            return {
+                data,
+                status: 200, // HttpClient only returns data on success
+                headers: {}, // Can extract from observe: 'response' if needed
+            };
+        }
+        catch (error) {
+            if (error instanceof HttpErrorResponse) {
+                // Convert Angular's HttpErrorResponse to NAuthClientError
+                const errorData = error.error || {};
+                const code = typeof errorData['code'] === 'string' ? errorData.code : NAuthErrorCode.INTERNAL_ERROR;
+                const message = typeof errorData['message'] === 'string'
+                    ? errorData.message
+                    : error.message || `Request failed with status ${error.status}`;
+                const timestamp = typeof errorData['timestamp'] === 'string' ? errorData.timestamp : undefined;
+                const details = errorData['details'];
+                throw new NAuthClientError(code, message, {
+                    statusCode: error.status,
+                    timestamp,
+                    details,
+                    isNetworkError: error.status === 0, // Network error (no response from server)
+                });
+            }
+            // Re-throw non-HTTP errors
+            throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularHttpAdapter, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularHttpAdapter });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularHttpAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ngmodule/nauth.module.mjs

@@ -0,0 +1,65 @@
+import { NgModule } from '@angular/core';
+import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { NAUTH_CLIENT_CONFIG } from './tokens';
+import { AuthService } from './auth.service';
+import { AngularHttpAdapter } from './http-adapter';
+import { AuthInterceptorClass } from './auth.interceptor.class';
+import * as i0 from "@angular/core";
+/**
+ * NgModule for nauth-toolkit Angular integration.
+ *
+ * Use this for NgModule-based apps (Angular 17+ with NgModule or legacy apps).
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * import { NAuthModule } from '@nauth-toolkit/client-angular';
+ *
+ * @NgModule({
+ *   imports: [
+ *     NAuthModule.forRoot({
+ *       baseUrl: 'http://localhost:3000/auth',
+ *       tokenDelivery: 'cookies',
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export class NAuthModule {
+    static forRoot(config) {
+        return {
+            ngModule: NAuthModule,
+            providers: [
+                {
+                    provide: NAUTH_CLIENT_CONFIG,
+                    useValue: config,
+                },
+                AngularHttpAdapter,
+                {
+                    provide: AuthService,
+                    useFactory: (httpAdapter) => {
+                        return new AuthService(config, httpAdapter);
+                    },
+                    deps: [AngularHttpAdapter],
+                },
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: AuthInterceptorClass,
+                    multi: true,
+                },
+            ],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: NAuthModule, imports: [HttpClientModule], exports: [HttpClientModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NAuthModule, imports: [HttpClientModule, HttpClientModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NAuthModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [HttpClientModule],
+                    exports: [HttpClientModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ngmodule/tokens.mjs

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for providing NAuthClientConfig in Angular apps.
+ */
+export const NAUTH_CLIENT_CONFIG = new InjectionToken('NAUTH_CLIENT_CONFIG');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL25nbW9kdWxlL3Rva2Vucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRy9DOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxjQUFjLENBQW9CLHFCQUFxQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTkF1dGhDbGllbnRDb25maWcgfSBmcm9tICdAbmF1dGgtdG9vbGtpdC9jbGllbnQnO1xuXG4vKipcbiAqIEluamVjdGlvbiB0b2tlbiBmb3IgcHJvdmlkaW5nIE5BdXRoQ2xpZW50Q29uZmlnIGluIEFuZ3VsYXIgYXBwcy5cbiAqL1xuZXhwb3J0IGNvbnN0IE5BVVRIX0NMSUVOVF9DT05GSUcgPSBuZXcgSW5qZWN0aW9uVG9rZW48TkF1dGhDbGllbnRDb25maWc+KCdOQVVUSF9DTElFTlRfQ09ORklHJyk7XG4iXX0=

package/esm2022/public-api.mjs

@@ -0,0 +1,19 @@
+/**
+ * Public API Surface of @nauth-toolkit/client-angular (NgModule)
+ *
+ * This is the default entry point for NgModule-based Angular apps.
+ * For standalone components, use: @nauth-toolkit/client-angular/standalone
+ */
+// Re-export core client types and utilities
+export * from '@nauth-toolkit/client';
+// Export NgModule-specific components (class-based)
+export * from './ngmodule/tokens';
+export * from './ngmodule/auth.service';
+export * from './ngmodule/http-adapter';
+export * from './ngmodule/auth.interceptor.class';
+export * from './ngmodule/nauth.module';
+// Export functional components (for flexibility in NgModule apps too)
+export * from './lib/auth.interceptor';
+export * from './lib/auth.guard';
+export * from './lib/social-redirect-callback.guard';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBRUgsNENBQTRDO0FBQzVDLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsb0RBQW9EO0FBQ3BELGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyx5QkFBeUIsQ0FBQztBQUV4QyxzRUFBc0U7QUFDdEUsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsc0NBQXNDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBAbmF1dGgtdG9vbGtpdC9jbGllbnQtYW5ndWxhciAoTmdNb2R1bGUpXG4gKlxuICogVGhpcyBpcyB0aGUgZGVmYXVsdCBlbnRyeSBwb2ludCBmb3IgTmdNb2R1bGUtYmFzZWQgQW5ndWxhciBhcHBzLlxuICogRm9yIHN0YW5kYWxvbmUgY29tcG9uZW50cywgdXNlOiBAbmF1dGgtdG9vbGtpdC9jbGllbnQtYW5ndWxhci9zdGFuZGFsb25lXG4gKi9cblxuLy8gUmUtZXhwb3J0IGNvcmUgY2xpZW50IHR5cGVzIGFuZCB1dGlsaXRpZXNcbmV4cG9ydCAqIGZyb20gJ0BuYXV0aC10b29sa2l0L2NsaWVudCc7XG5cbi8vIEV4cG9ydCBOZ01vZHVsZS1zcGVjaWZpYyBjb21wb25lbnRzIChjbGFzcy1iYXNlZClcbmV4cG9ydCAqIGZyb20gJy4vbmdtb2R1bGUvdG9rZW5zJztcbmV4cG9ydCAqIGZyb20gJy4vbmdtb2R1bGUvYXV0aC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbmdtb2R1bGUvaHR0cC1hZGFwdGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbmdtb2R1bGUvYXV0aC5pbnRlcmNlcHRvci5jbGFzcyc7XG5leHBvcnQgKiBmcm9tICcuL25nbW9kdWxlL25hdXRoLm1vZHVsZSc7XG5cbi8vIEV4cG9ydCBmdW5jdGlvbmFsIGNvbXBvbmVudHMgKGZvciBmbGV4aWJpbGl0eSBpbiBOZ01vZHVsZSBhcHBzIHRvbylcbmV4cG9ydCAqIGZyb20gJy4vbGliL2F1dGguaW50ZXJjZXB0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYXV0aC5ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zb2NpYWwtcmVkaXJlY3QtY2FsbGJhY2suZ3VhcmQnO1xuIl19

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

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

package/esm2022/src/standalone/public-api.mjs

@@ -0,0 +1,12 @@
+/**
+ * Public API Surface of @nauth-toolkit/client-angular/standalone
+ *
+ * This entry point is for standalone component-based Angular apps (Angular 14+).
+ * For NgModule apps, use: @nauth-toolkit/client-angular
+ *
+ * NOTE: This simply re-exports the main entry point since both share the same code for now.
+ * The split allows future additions like `provideNAuth()` for standalone apps.
+ */
+// Re-export everything from the main entry point
+export * from '@nauth-toolkit/client-angular';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zdGFuZGFsb25lL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFFSCxpREFBaUQ7QUFDakQsY0FBYywrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIEBuYXV0aC10b29sa2l0L2NsaWVudC1hbmd1bGFyL3N0YW5kYWxvbmVcbiAqXG4gKiBUaGlzIGVudHJ5IHBvaW50IGlzIGZvciBzdGFuZGFsb25lIGNvbXBvbmVudC1iYXNlZCBBbmd1bGFyIGFwcHMgKEFuZ3VsYXIgMTQrKS5cbiAqIEZvciBOZ01vZHVsZSBhcHBzLCB1c2U6IEBuYXV0aC10b29sa2l0L2NsaWVudC1hbmd1bGFyXG4gKlxuICogTk9URTogVGhpcyBzaW1wbHkgcmUtZXhwb3J0cyB0aGUgbWFpbiBlbnRyeSBwb2ludCBzaW5jZSBib3RoIHNoYXJlIHRoZSBzYW1lIGNvZGUgZm9yIG5vdy5cbiAqIFRoZSBzcGxpdCBhbGxvd3MgZnV0dXJlIGFkZGl0aW9ucyBsaWtlIGBwcm92aWRlTkF1dGgoKWAgZm9yIHN0YW5kYWxvbmUgYXBwcy5cbiAqL1xuXG4vLyBSZS1leHBvcnQgZXZlcnl0aGluZyBmcm9tIHRoZSBtYWluIGVudHJ5IHBvaW50XG5leHBvcnQgKiBmcm9tICdAbmF1dGgtdG9vbGtpdC9jbGllbnQtYW5ndWxhcic7XG4iXX0=

package/esm2022/standalone/auth.guard.mjs

@@ -0,0 +1,83 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { AuthService } from './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/standalone/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 './tokens';
+import { AuthService } from './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":["../../../standalone/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 './tokens';\nimport { AuthService } from './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"]}