@opensourcekd/ng-common-libs 1.1.8

package/dist/angular/index.cjs

@@ -0,0 +1,1273 @@
+'use strict';
+
+var core = require('@angular/core');
+var rxjs = require('rxjs');
+var operators = require('rxjs/operators');
+var router = require('@angular/router');
+var http = require('@angular/common/http');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * EventBus - A centralized event bus for application-wide communication
+ * Framework-agnostic implementation using only RxJS
+ *
+ * @example
+ * ```typescript
+ * // Create an instance
+ * const eventBus = new EventBus();
+ *
+ * // Emit an event
+ * eventBus.emit('user:login', { userId: '123', username: 'john' });
+ *
+ * // Subscribe to an event
+ * eventBus.on('user:login').subscribe(data => {
+ *   console.log('User logged in:', data);
+ * });
+ * ```
+ */
+class EventBus {
+    eventSubject = new rxjs.Subject();
+    /**
+     * Emit an event with optional data
+     * @param eventType - The type/name of the event
+     * @param data - Optional data to send with the event
+     */
+    emit(eventType, data) {
+        this.eventSubject.next({
+            type: eventType,
+            data,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Subscribe to a specific event type
+     * @param eventType - The type/name of the event to listen for
+     * @returns Observable that emits the event data
+     */
+    on(eventType) {
+        return this.eventSubject.asObservable().pipe(operators.filter(event => event.type === eventType), operators.map(event => event.data));
+    }
+    /**
+     * Subscribe to multiple event types
+     * @param eventTypes - Array of event types to listen for
+     * @returns Observable that emits the full event payload
+     */
+    onMultiple(eventTypes) {
+        return this.eventSubject.asObservable().pipe(operators.filter(event => eventTypes.includes(event.type)));
+    }
+    /**
+     * Subscribe to all events
+     * @returns Observable that emits all event payloads
+     */
+    onAll() {
+        return this.eventSubject.asObservable();
+    }
+}
+
+/**
+ * NgEventEmitter - Angular service wrapper for EventBus
+ * Provides Angular dependency injection support for the framework-agnostic EventBus
+ *
+ * @example
+ * ```typescript
+ * import { Component, inject } from '@angular/core';
+ * import { NgEventEmitter } from 'common-libs';
+ *
+ * @Component({
+ *   selector: 'app-example',
+ *   template: '...'
+ * })
+ * export class ExampleComponent {
+ *   private eventEmitter = inject(NgEventEmitter);
+ *
+ *   ngOnInit() {
+ *     this.eventEmitter.on('user:login').subscribe(data => {
+ *       console.log('User logged in:', data);
+ *     });
+ *   }
+ *
+ *   login() {
+ *     this.eventEmitter.emit('user:login', { userId: '123' });
+ *   }
+ * }
+ * ```
+ */
+exports.NgEventEmitter = class NgEventEmitter extends EventBus {
+    constructor() {
+        super();
+    }
+};
+exports.NgEventEmitter = __decorate([
+    core.Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [])
+], exports.NgEventEmitter);
+
+/**
+ * TokenManager - Manages authentication tokens
+ * Framework-agnostic implementation using browser storage APIs
+ * Handles storage, retrieval, and validation of JWT tokens
+ *
+ * @example
+ * ```typescript
+ * const tokenManager = new TokenManager();
+ *
+ * // Store a token
+ * tokenManager.setToken('your-jwt-token');
+ *
+ * // Check if authenticated
+ * if (tokenManager.isAuthenticated()) {
+ *   const userData = tokenManager.getUserFromToken();
+ * }
+ * ```
+ */
+class TokenManager {
+    TOKEN_KEY = 'auth_token';
+    REFRESH_TOKEN_KEY = 'refresh_token';
+    useSessionStorage = false;
+    /**
+     * Configure token manager
+     */
+    configure(config) {
+        if (config.tokenKey) {
+            this.TOKEN_KEY = config.tokenKey;
+        }
+        if (config.refreshTokenKey) {
+            this.REFRESH_TOKEN_KEY = config.refreshTokenKey;
+        }
+        if (config.useSessionStorage !== undefined) {
+            this.useSessionStorage = config.useSessionStorage;
+        }
+    }
+    /**
+     * Get the storage mechanism based on configuration
+     */
+    getStorage() {
+        return this.useSessionStorage ? sessionStorage : localStorage;
+    }
+    /**
+     * Set authentication token
+     */
+    setToken(token) {
+        this.getStorage().setItem(this.TOKEN_KEY, token);
+    }
+    /**
+     * Get authentication token
+     */
+    getToken() {
+        return this.getStorage().getItem(this.TOKEN_KEY);
+    }
+    /**
+     * Remove authentication token
+     */
+    removeToken() {
+        this.getStorage().removeItem(this.TOKEN_KEY);
+    }
+    /**
+     * Set refresh token
+     */
+    setRefreshToken(token) {
+        this.getStorage().setItem(this.REFRESH_TOKEN_KEY, token);
+    }
+    /**
+     * Get refresh token
+     */
+    getRefreshToken() {
+        return this.getStorage().getItem(this.REFRESH_TOKEN_KEY);
+    }
+    /**
+     * Remove refresh token
+     */
+    removeRefreshToken() {
+        this.getStorage().removeItem(this.REFRESH_TOKEN_KEY);
+    }
+    /**
+     * Clear all tokens
+     */
+    clearTokens() {
+        this.removeToken();
+        this.removeRefreshToken();
+    }
+    /**
+     * Check if token exists
+     */
+    hasToken() {
+        return !!this.getToken();
+    }
+    /**
+     * Decode JWT token (without verification)
+     * @param token - JWT token to decode
+     * @returns Decoded token payload or null if invalid
+     */
+    decodeToken(token) {
+        const tokenToDecode = token || this.getToken();
+        if (!tokenToDecode)
+            return null;
+        try {
+            const parts = tokenToDecode.split('.');
+            if (parts.length !== 3)
+                return null;
+            const payload = parts[1];
+            const decoded = JSON.parse(atob(payload.replace(/-/g, '+').replace(/_/g, '/')));
+            return decoded;
+        }
+        catch (error) {
+            console.error('Error decoding token:', error);
+            return null;
+        }
+    }
+    /**
+     * Check if token is expired
+     * @param token - Optional token to check (defaults to stored token)
+     * @returns true if token is expired or invalid
+     */
+    isTokenExpired(token) {
+        const decoded = this.decodeToken(token);
+        if (!decoded || !decoded.exp)
+            return true;
+        const expirationDate = new Date(decoded.exp * 1000);
+        return expirationDate <= new Date();
+    }
+    /**
+     * Check if user is authenticated (has valid, non-expired token)
+     */
+    isAuthenticated() {
+        return this.hasToken() && !this.isTokenExpired();
+    }
+    /**
+     * Get token expiration date
+     */
+    getTokenExpirationDate(token) {
+        const decoded = this.decodeToken(token);
+        if (!decoded || !decoded.exp)
+            return null;
+        return new Date(decoded.exp * 1000);
+    }
+    /**
+     * Get user data from token
+     */
+    getUserFromToken(token) {
+        return this.decodeToken(token);
+    }
+}
+
+/**
+ * TokenService - Angular service wrapper for TokenManager
+ * Provides Angular dependency injection support for the framework-agnostic TokenManager
+ *
+ * @example
+ * ```typescript
+ * import { Component, inject } from '@angular/core';
+ * import { TokenService } from 'common-libs';
+ *
+ * export class AuthService {
+ *   private tokenService = inject(TokenService);
+ *
+ *   login(token: string) {
+ *     this.tokenService.setToken(token);
+ *   }
+ *
+ *   isAuthenticated(): boolean {
+ *     return this.tokenService.isAuthenticated();
+ *   }
+ * }
+ * ```
+ */
+exports.TokenService = class TokenService extends TokenManager {
+    constructor() {
+        console.log("Hey Jude in TokenService of common-libs");
+        super();
+    }
+};
+exports.TokenService = __decorate([
+    core.Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [])
+], exports.TokenService);
+
+/**
+ * StorageManager - Type-safe wrapper for browser storage
+ * Framework-agnostic implementation using browser storage APIs
+ * Provides JSON serialization/deserialization and error handling
+ *
+ * @example
+ * ```typescript
+ * const storage = new StorageManager();
+ *
+ * // Store data
+ * storage.setLocal('user-prefs', { theme: 'dark', lang: 'en' });
+ *
+ * // Retrieve data
+ * const prefs = storage.getLocal('user-prefs');
+ *
+ * // With expiration
+ * storage.setWithExpiration('temp-data', someData, 3600000); // 1 hour
+ * ```
+ */
+class StorageManager {
+    /**
+     * Set item in localStorage with JSON serialization
+     */
+    setLocal(key, value) {
+        try {
+            const serialized = JSON.stringify(value);
+            localStorage.setItem(key, serialized);
+            return true;
+        }
+        catch (error) {
+            console.error('Error setting localStorage item:', error);
+            return false;
+        }
+    }
+    /**
+     * Get item from localStorage with JSON deserialization
+     */
+    getLocal(key, defaultValue) {
+        try {
+            const item = localStorage.getItem(key);
+            if (item === null) {
+                return defaultValue !== undefined ? defaultValue : null;
+            }
+            return JSON.parse(item);
+        }
+        catch (error) {
+            console.error('Error getting localStorage item:', error);
+            return defaultValue !== undefined ? defaultValue : null;
+        }
+    }
+    /**
+     * Remove item from localStorage
+     */
+    removeLocal(key) {
+        try {
+            localStorage.removeItem(key);
+        }
+        catch (error) {
+            console.error('Error removing localStorage item:', error);
+        }
+    }
+    /**
+     * Clear all localStorage items
+     */
+    clearLocal() {
+        try {
+            localStorage.clear();
+        }
+        catch (error) {
+            console.error('Error clearing localStorage:', error);
+        }
+    }
+    /**
+     * Check if key exists in localStorage
+     */
+    hasLocal(key) {
+        try {
+            return localStorage.getItem(key) !== null;
+        }
+        catch (error) {
+            console.error('Error checking localStorage key:', error);
+            return false;
+        }
+    }
+    /**
+     * Get all localStorage keys
+     */
+    getLocalKeys() {
+        try {
+            return Object.keys(localStorage);
+        }
+        catch (error) {
+            console.error('Error getting localStorage keys:', error);
+            return [];
+        }
+    }
+    /**
+     * Set item in sessionStorage with JSON serialization
+     */
+    setSession(key, value) {
+        try {
+            const serialized = JSON.stringify(value);
+            sessionStorage.setItem(key, serialized);
+            return true;
+        }
+        catch (error) {
+            console.error('Error setting sessionStorage item:', error);
+            return false;
+        }
+    }
+    /**
+     * Get item from sessionStorage with JSON deserialization
+     */
+    getSession(key, defaultValue) {
+        try {
+            const item = sessionStorage.getItem(key);
+            if (item === null) {
+                return defaultValue !== undefined ? defaultValue : null;
+            }
+            return JSON.parse(item);
+        }
+        catch (error) {
+            console.error('Error getting sessionStorage item:', error);
+            return defaultValue !== undefined ? defaultValue : null;
+        }
+    }
+    /**
+     * Remove item from sessionStorage
+     */
+    removeSession(key) {
+        try {
+            sessionStorage.removeItem(key);
+        }
+        catch (error) {
+            console.error('Error removing sessionStorage item:', error);
+        }
+    }
+    /**
+     * Clear all sessionStorage items
+     */
+    clearSession() {
+        try {
+            sessionStorage.clear();
+        }
+        catch (error) {
+            console.error('Error clearing sessionStorage:', error);
+        }
+    }
+    /**
+     * Check if key exists in sessionStorage
+     */
+    hasSession(key) {
+        try {
+            return sessionStorage.getItem(key) !== null;
+        }
+        catch (error) {
+            console.error('Error checking sessionStorage key:', error);
+            return false;
+        }
+    }
+    /**
+     * Get all sessionStorage keys
+     */
+    getSessionKeys() {
+        try {
+            return Object.keys(sessionStorage);
+        }
+        catch (error) {
+            console.error('Error getting sessionStorage keys:', error);
+            return [];
+        }
+    }
+    /**
+     * Set item with expiration time
+     * @param key - Storage key
+     * @param value - Value to store
+     * @param expirationMs - Expiration time in milliseconds
+     * @param useSession - Use sessionStorage instead of localStorage
+     */
+    setWithExpiration(key, value, expirationMs, useSession = false) {
+        const item = {
+            value,
+            expiration: Date.now() + expirationMs
+        };
+        return useSession
+            ? this.setSession(key, item)
+            : this.setLocal(key, item);
+    }
+    /**
+     * Get item with expiration check
+     * Returns null if item is expired
+     */
+    getWithExpiration(key, useSession = false) {
+        const item = useSession
+            ? this.getSession(key)
+            : this.getLocal(key);
+        if (!item)
+            return null;
+        if (Date.now() > item.expiration) {
+            // Item expired, remove it
+            if (useSession) {
+                this.removeSession(key);
+            }
+            else {
+                this.removeLocal(key);
+            }
+            return null;
+        }
+        return item.value;
+    }
+}
+
+/**
+ * StorageService - Angular service wrapper for StorageManager
+ * Provides Angular dependency injection support for the framework-agnostic StorageManager
+ *
+ * @example
+ * ```typescript
+ * import { Component, inject } from '@angular/core';
+ * import { StorageService } from 'common-libs';
+ *
+ * export class UserPreferencesService {
+ *   private storage = inject(StorageService);
+ *
+ *   savePreferences(prefs: any) {
+ *     this.storage.setLocal('user-prefs', prefs);
+ *   }
+ *
+ *   getPreferences() {
+ *     return this.storage.getLocal('user-prefs');
+ *   }
+ * }
+ * ```
+ */
+exports.StorageService = class StorageService extends StorageManager {
+    constructor() {
+        super();
+    }
+};
+exports.StorageService = __decorate([
+    core.Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [])
+], exports.StorageService);
+
+/**
+ * Log level enum
+ */
+exports.LogLevel = void 0;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["NONE"] = 4] = "NONE";
+})(exports.LogLevel || (exports.LogLevel = {}));
+/**
+ * Logger - Centralized logging utility
+ * Framework-agnostic implementation using browser console APIs
+ * Supports different log levels and can be configured globally
+ *
+ * @example
+ * ```typescript
+ * const logger = new Logger();
+ *
+ * // Configure
+ * logger.configure({
+ *   level: LogLevel.DEBUG,
+ *   enableTimestamp: true,
+ *   prefix: 'MyApp'
+ * });
+ *
+ * // Use
+ * logger.info('User logged in', { userId: '123' });
+ * logger.error('Failed to load data', error);
+ * ```
+ */
+class Logger {
+    config = {
+        level: exports.LogLevel.INFO,
+        enableTimestamp: true,
+        enableStackTrace: false,
+        prefix: ''
+    };
+    /**
+     * Configure the logger
+     */
+    configure(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Set log level
+     */
+    setLevel(level) {
+        this.config.level = level;
+    }
+    /**
+     * Get current log level
+     */
+    getLevel() {
+        return this.config.level;
+    }
+    /**
+     * Format log message with timestamp and prefix
+     */
+    formatMessage(message, level) {
+        const parts = [];
+        if (this.config.enableTimestamp) {
+            parts.push(`[${new Date().toISOString()}]`);
+        }
+        if (this.config.prefix) {
+            parts.push(`[${this.config.prefix}]`);
+        }
+        parts.push(`[${level}]`);
+        parts.push(message);
+        return parts.join(' ');
+    }
+    /**
+     * Check if log level should be logged
+     */
+    shouldLog(level) {
+        return level >= this.config.level;
+    }
+    /**
+     * Log debug message
+     */
+    debug(message, ...args) {
+        if (this.shouldLog(exports.LogLevel.DEBUG)) {
+            console.debug(this.formatMessage(message, 'DEBUG'), ...args);
+        }
+    }
+    /**
+     * Log info message
+     */
+    info(message, ...args) {
+        if (this.shouldLog(exports.LogLevel.INFO)) {
+            console.info(this.formatMessage(message, 'INFO'), ...args);
+        }
+    }
+    /**
+     * Log warning message
+     */
+    warn(message, ...args) {
+        if (this.shouldLog(exports.LogLevel.WARN)) {
+            console.warn(this.formatMessage(message, 'WARN'), ...args);
+        }
+    }
+    /**
+     * Log error message
+     */
+    error(message, error, ...args) {
+        if (this.shouldLog(exports.LogLevel.ERROR)) {
+            console.error(this.formatMessage(message, 'ERROR'), ...args);
+            if (error) {
+                console.error(error);
+                if (this.config.enableStackTrace && error?.stack) {
+                    console.error('Stack trace:', error.stack);
+                }
+            }
+        }
+    }
+    /**
+     * Log a group of messages
+     */
+    group(label, callback) {
+        if (this.shouldLog(exports.LogLevel.INFO)) {
+            console.group(this.formatMessage(label, 'GROUP'));
+            callback();
+            console.groupEnd();
+        }
+    }
+    /**
+     * Log a collapsed group of messages
+     */
+    groupCollapsed(label, callback) {
+        if (this.shouldLog(exports.LogLevel.INFO)) {
+            console.groupCollapsed(this.formatMessage(label, 'GROUP'));
+            callback();
+            console.groupEnd();
+        }
+    }
+    /**
+     * Log a table (useful for arrays of objects)
+     */
+    table(data, columns) {
+        if (this.shouldLog(exports.LogLevel.INFO)) {
+            console.table(data, columns);
+        }
+    }
+    /**
+     * Log execution time of a function
+     */
+    async time(label, fn) {
+        const start = performance.now();
+        try {
+            const result = await fn();
+            const end = performance.now();
+            const duration = (end - start).toFixed(2);
+            this.info(`${label} completed in ${duration}ms`);
+            return result;
+        }
+        catch (error) {
+            const end = performance.now();
+            const duration = (end - start).toFixed(2);
+            this.error(`${label} failed after ${duration}ms`, error);
+            throw error;
+        }
+    }
+}
+
+/**
+ * LoggerService - Angular service wrapper for Logger
+ * Provides Angular dependency injection support for the framework-agnostic Logger
+ *
+ * @example
+ * ```typescript
+ * import { Component, inject } from '@angular/core';
+ * import { LoggerService, LogLevel } from 'common-libs';
+ *
+ * export class MyService {
+ *   private logger = inject(LoggerService);
+ *
+ *   constructor() {
+ *     this.logger.configure({
+ *       level: LogLevel.DEBUG,
+ *       prefix: 'MyApp'
+ *     });
+ *   }
+ *
+ *   doSomething() {
+ *     this.logger.info('Doing something');
+ *   }
+ * }
+ * ```
+ */
+exports.LoggerService = class LoggerService extends Logger {
+    constructor() {
+        super();
+    }
+};
+exports.LoggerService = __decorate([
+    core.Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [])
+], exports.LoggerService);
+
+/**
+ * PermissionService - Manages user permissions and roles
+ */
+exports.PermissionService = class PermissionService {
+    tokenService = core.inject(exports.TokenService);
+    /**
+     * Check if user has a specific permission
+     */
+    hasPermission(permission) {
+        const user = this.tokenService.getUserFromToken();
+        const permissions = user?.permissions || [];
+        return permissions.includes(permission);
+    }
+    /**
+     * Check if user has any of the specified permissions
+     */
+    hasAnyPermission(permissions) {
+        return permissions.some(permission => this.hasPermission(permission));
+    }
+    /**
+     * Check if user has all of the specified permissions
+     */
+    hasAllPermissions(permissions) {
+        return permissions.every(permission => this.hasPermission(permission));
+    }
+    /**
+     * Check if user has a specific role
+     */
+    hasRole(role) {
+        const user = this.tokenService.getUserFromToken();
+        const roles = user?.roles || [];
+        return roles.includes(role);
+    }
+    /**
+     * Check if user has any of the specified roles
+     */
+    hasAnyRole(roles) {
+        return roles.some(role => this.hasRole(role));
+    }
+    /**
+     * Check if user has all of the specified roles
+     */
+    hasAllRoles(roles) {
+        return roles.every(role => this.hasRole(role));
+    }
+    /**
+     * Get all user permissions
+     */
+    getPermissions() {
+        const user = this.tokenService.getUserFromToken();
+        return user?.permissions || [];
+    }
+    /**
+     * Get all user roles
+     */
+    getRoles() {
+        const user = this.tokenService.getUserFromToken();
+        return user?.roles || [];
+    }
+    /**
+     * Get user ID from token
+     */
+    getUserId() {
+        const user = this.tokenService.getUserFromToken();
+        return user?.sub || user?.id || user?.userId || null;
+    }
+    /**
+     * Get username from token
+     */
+    getUsername() {
+        const user = this.tokenService.getUserFromToken();
+        return user?.username || user?.name || user?.email || null;
+    }
+    /**
+     * Get user email from token
+     */
+    getUserEmail() {
+        const user = this.tokenService.getUserFromToken();
+        return user?.email || null;
+    }
+};
+exports.PermissionService = __decorate([
+    core.Injectable({
+        providedIn: 'root'
+    })
+], exports.PermissionService);
+
+/**
+ * Factory function to create an auth guard with configuration
+ *
+ * @example
+ * ```typescript
+ * // In routes
+ * {
+ *   path: 'dashboard',
+ *   component: DashboardComponent,
+ *   canActivate: [createAuthGuard({ redirectUrl: '/login' })]
+ * }
+ * ```
+ */
+function createAuthGuard(config = {}) {
+    return (route, state) => {
+        const tokenService = core.inject(exports.TokenService);
+        const router$1 = core.inject(router.Router);
+        const redirectUrl = config.redirectUrl || '/login';
+        const checkExpiration = config.checkExpiration !== false;
+        const hasToken = tokenService.hasToken();
+        const isExpired = checkExpiration ? tokenService.isTokenExpired() : false;
+        if (hasToken && !isExpired) {
+            return true;
+        }
+        // Store the attempted URL for redirecting after login
+        const returnUrl = state.url;
+        router$1.navigate([redirectUrl], {
+            queryParams: { returnUrl },
+            queryParamsHandling: 'merge'
+        });
+        return false;
+    };
+}
+/**
+ * Default auth guard - redirects to '/login' if not authenticated
+ */
+const authGuard = createAuthGuard();
+/**
+ * Permission-based guard factory
+ * Checks if user has required permissions from token
+ *
+ * @example
+ * ```typescript
+ * {
+ *   path: 'admin',
+ *   component: AdminComponent,
+ *   canActivate: [createPermissionGuard(['admin', 'editor'])]
+ * }
+ * ```
+ */
+function createPermissionGuard(requiredPermissions, config = {}) {
+    return (route, state) => {
+        const tokenService = core.inject(exports.TokenService);
+        const router$1 = core.inject(router.Router);
+        const redirectUrl = config.redirectUrl || '/unauthorized';
+        // First check authentication
+        if (!tokenService.isAuthenticated()) {
+            router$1.navigate(['/login'], {
+                queryParams: { returnUrl: state.url }
+            });
+            return false;
+        }
+        // Check permissions
+        const user = tokenService.getUserFromToken();
+        const userPermissions = user?.permissions || user?.roles || [];
+        const hasPermission = requiredPermissions.some(permission => userPermissions.includes(permission));
+        if (!hasPermission) {
+            router$1.navigate([redirectUrl]);
+            return false;
+        }
+        return true;
+    };
+}
+/**
+ * Role-based guard factory
+ * Checks if user has required role from token
+ *
+ * @example
+ * ```typescript
+ * {
+ *   path: 'admin',
+ *   component: AdminComponent,
+ *   canActivate: [createRoleGuard(['admin'])]
+ * }
+ * ```
+ */
+function createRoleGuard(requiredRoles, config = {}) {
+    return createPermissionGuard(requiredRoles, config);
+}
+
+const defaultConfig$1 = {
+    headerName: 'Authorization',
+    tokenPrefix: 'Bearer',
+    excludedUrls: []
+};
+let interceptorConfig = { ...defaultConfig$1 };
+/**
+ * Configure the auth interceptor
+ */
+function configureAuthInterceptor(config) {
+    interceptorConfig = { ...defaultConfig$1, ...config };
+}
+/**
+ * Auth Interceptor - Automatically adds authentication token to HTTP requests
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(
+ *       withInterceptors([authInterceptor])
+ *     )
+ *   ]
+ * };
+ * ```
+ */
+const authInterceptor = (req, next) => {
+    const tokenService = core.inject(exports.TokenService);
+    const config = interceptorConfig;
+    // Check if URL should be excluded
+    const isExcluded = config.excludedUrls?.some(url => req.url.includes(url));
+    if (isExcluded) {
+        return next(req);
+    }
+    // Get token and add to request if available
+    const token = tokenService.getToken();
+    if (token) {
+        const authReq = req.clone({
+            setHeaders: {
+                [config.headerName]: `${config.tokenPrefix} ${token}`
+            }
+        });
+        return next(authReq);
+    }
+    return next(req);
+};
+
+const defaultConfig = {
+    enableLogging: true,
+    retryAttempts: 0,
+    retryDelay: 1000,
+    retryStatusCodes: [408, 429, 500, 502, 503, 504],
+    excludedUrls: []
+};
+let errorConfig = { ...defaultConfig };
+/**
+ * Configure the error handling interceptor
+ */
+function configureErrorHandling(config) {
+    errorConfig = { ...defaultConfig, ...config };
+}
+/**
+ * Error handling interceptor - Handles HTTP errors and retries
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(
+ *       withInterceptors([errorHandlingInterceptor])
+ *     )
+ *   ]
+ * };
+ *
+ * // Configure retry behavior
+ * configureErrorHandling({
+ *   retryAttempts: 3,
+ *   retryDelay: 2000,
+ *   retryStatusCodes: [500, 502, 503]
+ * });
+ * ```
+ */
+const errorHandlingInterceptor = (req, next) => {
+    const logger = core.inject(exports.LoggerService);
+    const config = errorConfig;
+    // Check if URL should be excluded
+    const isExcluded = config.excludedUrls?.some(url => req.url.includes(url));
+    if (isExcluded) {
+        return next(req);
+    }
+    return next(req).pipe(
+    // Retry logic with exponential backoff
+    operators.retry({
+        count: config.retryAttempts,
+        delay: (error, retryCount) => {
+            // Only retry for specific status codes
+            if (!config.retryStatusCodes?.includes(error.status)) {
+                return rxjs.throwError(() => error);
+            }
+            const delay = config.retryDelay * Math.pow(2, retryCount - 1);
+            if (config.enableLogging) {
+                logger.warn(`Retrying request (attempt ${retryCount}) after ${delay}ms`, { url: req.url, status: error.status });
+            }
+            return rxjs.timer(delay);
+        }
+    }), 
+    // Error handling
+    operators.catchError((error) => {
+        if (config.enableLogging) {
+            logger.error('HTTP request failed', error, {
+                url: req.url,
+                status: error.status,
+                message: error.message
+            });
+        }
+        return rxjs.throwError(() => error);
+    }));
+};
+/**
+ * HTTP Error class with additional context
+ */
+class HttpError extends Error {
+    status;
+    statusText;
+    url;
+    originalError;
+    constructor(status, statusText, url, originalError) {
+        super(`HTTP ${status} ${statusText}: ${url}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.url = url;
+        this.originalError = originalError;
+        this.name = 'HttpError';
+    }
+}
+/**
+ * Parse HTTP error and return user-friendly message
+ */
+function parseHttpError(error) {
+    if (error.error instanceof ErrorEvent) {
+        // Client-side error
+        return `Network error: ${error.error.message}`;
+    }
+    else {
+        // Server-side error
+        const errorMessage = error.error?.message || error.message || 'Unknown error';
+        return `Server error (${error.status}): ${errorMessage}`;
+    }
+}
+/**
+ * Check if error is a network error
+ */
+function isNetworkError(error) {
+    return error.error instanceof ErrorEvent || error.status === 0;
+}
+/**
+ * Check if error is a server error (5xx)
+ */
+function isServerError(error) {
+    return error.status >= 500 && error.status < 600;
+}
+/**
+ * Check if error is a client error (4xx)
+ */
+function isClientError(error) {
+    return error.status >= 400 && error.status < 500;
+}
+
+const defaultCacheConfig = {
+    enabled: true,
+    maxAge: 60000, // 1 minute
+    excludedUrls: [],
+    cacheableUrls: [],
+    cacheMethods: ['GET']
+};
+let cacheConfig = { ...defaultCacheConfig };
+const cache = new Map();
+const MAX_CACHE_SIZE = 100; // Maximum number of cached entries
+/**
+ * Configure the caching interceptor
+ */
+function configureCaching(config) {
+    cacheConfig = { ...defaultCacheConfig, ...config };
+}
+/**
+ * Clean up expired cache entries
+ */
+function cleanupCache() {
+    const now = Date.now();
+    const keysToDelete = [];
+    cache.forEach((entry, key) => {
+        const age = now - entry.timestamp;
+        if (age >= cacheConfig.maxAge) {
+            keysToDelete.push(key);
+        }
+    });
+    keysToDelete.forEach(key => cache.delete(key));
+}
+/**
+ * Evict oldest cache entry if cache is full
+ */
+function evictOldestIfFull() {
+    if (cache.size >= MAX_CACHE_SIZE) {
+        let oldestKey = null;
+        let oldestTimestamp = Infinity;
+        cache.forEach((entry, key) => {
+            if (entry.timestamp < oldestTimestamp) {
+                oldestTimestamp = entry.timestamp;
+                oldestKey = key;
+            }
+        });
+        if (oldestKey) {
+            cache.delete(oldestKey);
+        }
+    }
+}
+/**
+ * Clear all cached entries
+ */
+function clearCache() {
+    cache.clear();
+}
+/**
+ * Clear cache entry for specific URL
+ */
+function clearCacheEntry(url) {
+    cache.delete(url);
+}
+/**
+ * Caching interceptor - Caches HTTP GET requests
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(
+ *       withInterceptors([cachingInterceptor])
+ *     )
+ *   ]
+ * };
+ *
+ * // Configure caching
+ * configureCaching({
+ *   enabled: true,
+ *   maxAge: 300000, // 5 minutes
+ *   cacheableUrls: ['/api/users', '/api/products']
+ * });
+ * ```
+ */
+const cachingInterceptor = (req, next) => {
+    const logger = core.inject(exports.LoggerService);
+    const config = cacheConfig;
+    // Only cache if enabled
+    if (!config.enabled) {
+        return next(req);
+    }
+    // Only cache specific methods (default: GET)
+    if (!config.cacheMethods?.includes(req.method)) {
+        return next(req);
+    }
+    // Check if URL should be excluded
+    const isExcluded = config.excludedUrls?.some(url => req.url.includes(url));
+    if (isExcluded) {
+        return next(req);
+    }
+    // Check if URL is explicitly cacheable (if list is provided)
+    if (config.cacheableUrls && config.cacheableUrls.length > 0) {
+        const isCacheable = config.cacheableUrls.some(url => req.url.includes(url));
+        if (!isCacheable) {
+            return next(req);
+        }
+    }
+    const cacheKey = req.urlWithParams;
+    // Check cache
+    const cached = cache.get(cacheKey);
+    if (cached) {
+        const age = Date.now() - cached.timestamp;
+        if (age < config.maxAge) {
+            logger.debug(`Cache hit for ${cacheKey}`, { age });
+            return new rxjs.Observable(observer => {
+                observer.next(cached.response.clone());
+                observer.complete();
+            });
+        }
+        else {
+            // Cache expired
+            cache.delete(cacheKey);
+        }
+    }
+    // Clean up expired entries periodically
+    if (Math.random() < 0.1) { // 10% chance on each request
+        cleanupCache();
+    }
+    // Make request and cache response
+    return next(req).pipe(operators.tap(event => {
+        if (event instanceof http.HttpResponse) {
+            evictOldestIfFull();
+            cache.set(cacheKey, {
+                response: event.clone(),
+                timestamp: Date.now()
+            });
+            logger.debug(`Cached response for ${cacheKey}`);
+        }
+    }));
+};
+
+exports.HttpError = HttpError;
+exports.authGuard = authGuard;
+exports.authInterceptor = authInterceptor;
+exports.cachingInterceptor = cachingInterceptor;
+exports.clearCache = clearCache;
+exports.clearCacheEntry = clearCacheEntry;
+exports.configureAuthInterceptor = configureAuthInterceptor;
+exports.configureCaching = configureCaching;
+exports.configureErrorHandling = configureErrorHandling;
+exports.createAuthGuard = createAuthGuard;
+exports.createPermissionGuard = createPermissionGuard;
+exports.createRoleGuard = createRoleGuard;
+exports.errorHandlingInterceptor = errorHandlingInterceptor;
+exports.isClientError = isClientError;
+exports.isNetworkError = isNetworkError;
+exports.isServerError = isServerError;
+exports.parseHttpError = parseHttpError;
+//# sourceMappingURL=index.cjs.map