@nauth-toolkit/client-angular 0.1.56 → 0.1.58

package/esm2022/ngmodule/http-adapter.mjs

@@ -0,0 +1,127 @@
+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;
+    }
+    /**
+     * Safely parse a JSON response body.
+     *
+     * Angular's fetch backend (`withFetch()`) will throw a raw `SyntaxError` if
+     * `responseType: 'json'` is used and the backend returns HTML (common for
+     * proxies, 502 pages, SSR fallbacks, or misrouted requests).
+     *
+     * To avoid crashing consumer apps, we always request as text and then parse
+     * JSON only when the response actually looks like JSON.
+     *
+     * @param bodyText - Raw response body as text
+     * @param contentType - Content-Type header value (if available)
+     * @returns Parsed JSON value (unknown)
+     * @throws {SyntaxError} When body is non-empty but not valid JSON
+     */
+    parseJsonBody(bodyText, contentType) {
+        const trimmed = bodyText.trim();
+        if (!trimmed)
+            return null;
+        // If it's clearly HTML, never attempt JSON.parse (some proxies mislabel Content-Type).
+        if (trimmed.startsWith('<')) {
+            return bodyText;
+        }
+        const looksLikeJson = trimmed.startsWith('{') || trimmed.startsWith('[');
+        const isJsonContentType = typeof contentType === 'string' && contentType.toLowerCase().includes('application/json');
+        if (!looksLikeJson && !isJsonContentType) {
+            // Return raw text when it doesn't look like JSON (e.g., HTML error pages).
+            return bodyText;
+        }
+        return JSON.parse(trimmed);
+    }
+    /**
+     * 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.
+            // IMPORTANT: Use responseType 'text' to avoid raw JSON.parse crashes when
+            // the backend returns HTML (seen in some proxy/SSR/misroute setups).
+            const res = await firstValueFrom(this.http.request(config.method, config.url, {
+                body: config.body,
+                headers: config.headers,
+                withCredentials: config.credentials === 'include',
+                observe: 'response',
+                responseType: 'text',
+            }));
+            const contentType = res.headers?.get('content-type');
+            const parsed = this.parseJsonBody(res.body ?? '', contentType);
+            return {
+                data: parsed,
+                status: res.status,
+                headers: {}, // Reserved for future header passthrough if needed
+            };
+        }
+        catch (error) {
+            if (error instanceof HttpErrorResponse) {
+                // Convert Angular's HttpErrorResponse to NAuthClientError.
+                // When using responseType 'text', `error.error` is typically a string.
+                const contentType = error.headers?.get('content-type') ?? null;
+                const rawBody = typeof error.error === 'string' ? error.error : '';
+                const parsedError = this.parseJsonBody(rawBody, contentType);
+                const errorData = typeof parsedError === 'object' && parsedError !== null ? parsedError : {};
+                const code = typeof errorData['code'] === 'string' ? errorData['code'] : NAuthErrorCode.INTERNAL_ERROR;
+                const message = typeof errorData['message'] === 'string'
+                    ? errorData['message']
+                    : typeof parsedError === 'string' && parsedError.trim()
+                        ? parsedError
+                        : error.message || `Request failed with status ${error.status}`;
+                const timestamp = typeof errorData['timestamp'] === 'string' ? errorData['timestamp'] : undefined;
+                const details = typeof errorData['details'] === 'object' ? errorData['details'] : undefined;
+                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 as an SDK error so consumers don't see raw parser crashes.
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new NAuthClientError(NAuthErrorCode.INTERNAL_ERROR, message, {
+                statusCode: 0,
+                isNetworkError: true,
+            });
+        }
+    }
+    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,{"version":3,"file":"http-adapter.js","sourceRoot":"","sources":["../../../src/ngmodule/http-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\nimport { HttpAdapter, HttpRequest, HttpResponse, NAuthClientError, NAuthErrorCode } from '@nauth-toolkit/client';\n\n/**\n * HTTP adapter for Angular using HttpClient.\n *\n * This adapter:\n * - Uses Angular's HttpClient for all requests\n * - Works with Angular's HTTP interceptors (including authInterceptor)\n * - Auto-provided via Angular DI (providedIn: 'root')\n * - Converts HttpClient responses to HttpResponse format\n * - Converts HttpErrorResponse to NAuthClientError\n *\n * Users don't need to configure this manually - it's automatically\n * injected when using AuthService in Angular apps.\n *\n * @example\n * ```typescript\n * // Automatic usage (no manual setup needed)\n * // AuthService automatically injects AngularHttpAdapter\n * constructor(private auth: AuthService) {}\n * ```\n */\n@Injectable()\nexport class AngularHttpAdapter implements HttpAdapter {\n  constructor(private readonly http: HttpClient) {}\n\n  /**\n   * Safely parse a JSON response body.\n   *\n   * Angular's fetch backend (`withFetch()`) will throw a raw `SyntaxError` if\n   * `responseType: 'json'` is used and the backend returns HTML (common for\n   * proxies, 502 pages, SSR fallbacks, or misrouted requests).\n   *\n   * To avoid crashing consumer apps, we always request as text and then parse\n   * JSON only when the response actually looks like JSON.\n   *\n   * @param bodyText - Raw response body as text\n   * @param contentType - Content-Type header value (if available)\n   * @returns Parsed JSON value (unknown)\n   * @throws {SyntaxError} When body is non-empty but not valid JSON\n   */\n  private parseJsonBody(bodyText: string, contentType: string | null): unknown {\n    const trimmed = bodyText.trim();\n    if (!trimmed) return null;\n\n    // If it's clearly HTML, never attempt JSON.parse (some proxies mislabel Content-Type).\n    if (trimmed.startsWith('<')) {\n      return bodyText;\n    }\n\n    const looksLikeJson = trimmed.startsWith('{') || trimmed.startsWith('[');\n    const isJsonContentType = typeof contentType === 'string' && contentType.toLowerCase().includes('application/json');\n\n    if (!looksLikeJson && !isJsonContentType) {\n      // Return raw text when it doesn't look like JSON (e.g., HTML error pages).\n      return bodyText;\n    }\n\n    return JSON.parse(trimmed) as unknown;\n  }\n\n  /**\n   * Execute HTTP request using Angular's HttpClient.\n   *\n   * @param config - Request configuration\n   * @returns Response with parsed data\n   * @throws NAuthClientError if request fails\n   */\n  async request<T>(config: HttpRequest): Promise<HttpResponse<T>> {\n    try {\n      // Use Angular's HttpClient - goes through ALL interceptors.\n      // IMPORTANT: Use responseType 'text' to avoid raw JSON.parse crashes when\n      // the backend returns HTML (seen in some proxy/SSR/misroute setups).\n      const res = await firstValueFrom(\n        this.http.request(config.method, config.url, {\n          body: config.body,\n          headers: config.headers,\n          withCredentials: config.credentials === 'include',\n          observe: 'response',\n          responseType: 'text',\n        }),\n      );\n\n      const contentType = res.headers?.get('content-type');\n      const parsed = this.parseJsonBody(res.body ?? '', contentType);\n\n      return {\n        data: parsed as T,\n        status: res.status,\n        headers: {}, // Reserved for future header passthrough if needed\n      };\n    } catch (error) {\n      if (error instanceof HttpErrorResponse) {\n        // Convert Angular's HttpErrorResponse to NAuthClientError.\n        // When using responseType 'text', `error.error` is typically a string.\n        const contentType = error.headers?.get('content-type') ?? null;\n        const rawBody = typeof error.error === 'string' ? error.error : '';\n        const parsedError = this.parseJsonBody(rawBody, contentType);\n\n        const errorData =\n          typeof parsedError === 'object' && parsedError !== null ? (parsedError as Record<string, unknown>) : {};\n        const code =\n          typeof errorData['code'] === 'string' ? (errorData['code'] as NAuthErrorCode) : NAuthErrorCode.INTERNAL_ERROR;\n        const message =\n          typeof errorData['message'] === 'string'\n            ? (errorData['message'] as string)\n            : typeof parsedError === 'string' && parsedError.trim()\n              ? parsedError\n              : error.message || `Request failed with status ${error.status}`;\n        const timestamp = typeof errorData['timestamp'] === 'string' ? (errorData['timestamp'] as string) : undefined;\n        const details =\n          typeof errorData['details'] === 'object' ? (errorData['details'] as Record<string, unknown>) : undefined;\n\n        throw new NAuthClientError(code, message, {\n          statusCode: error.status,\n          timestamp,\n          details,\n          isNetworkError: error.status === 0, // Network error (no response from server)\n        });\n      }\n\n      // Re-throw non-HTTP errors as an SDK error so consumers don't see raw parser crashes.\n      const message = error instanceof Error ? error.message : 'Unknown error';\n      throw new NAuthClientError(NAuthErrorCode.INTERNAL_ERROR, message, {\n        statusCode: 0,\n        isNetworkError: true,\n      });\n    }\n  }\n}\n"]}

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"]}