@opensourcekd/ng-common-libs 1.2.4 → 1.2.5

package/dist/angular/index.mjs

@@ -1,8 +1,6 @@
-import { Injectable, inject } from '@angular/core';
-import { Subject, ReplaySubject, BehaviorSubject, throwError, timer, Observable } from 'rxjs';
-import { filter, map, retry, catchError, tap } from 'rxjs/operators';
-import { HttpClient, HttpResponse } from '@angular/common/http';
-import { Router } from '@angular/router';
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { ReplaySubject, BehaviorSubject } from 'rxjs';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -37,821 +35,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     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 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(filter(event => event.type === eventType), 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(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' });
- *   }
- * }
- * ```
- */
-let NgEventEmitter = class NgEventEmitter extends EventBus {
-    constructor() {
-        super();
-    }
-};
-NgEventEmitter = __decorate([
-    Injectable({
-        providedIn: 'root'
-    }),
-    __metadata("design:paramtypes", [])
-], 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();
- *   }
- * }
- * ```
- */
-let TokenService = class TokenService extends TokenManager {
-    constructor() {
-        console.log("In TokenService of opensourcekd 2");
-        super();
-    }
-};
-TokenService = __decorate([
-    Injectable({
-        providedIn: 'root'
-    }),
-    __metadata("design:paramtypes", [])
-], 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');
- *   }
- * }
- * ```
- */
-let StorageService = class StorageService extends StorageManager {
-    constructor() {
-        super();
-    }
-};
-StorageService = __decorate([
-    Injectable({
-        providedIn: 'root'
-    }),
-    __metadata("design:paramtypes", [])
-], StorageService);
-
-/**
- * Log level enum
- */
-var LogLevel;
-(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";
-})(LogLevel || (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: 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(LogLevel.DEBUG)) {
-            console.debug(this.formatMessage(message, 'DEBUG'), ...args);
-        }
-    }
-    /**
-     * Log info message
-     */
-    info(message, ...args) {
-        if (this.shouldLog(LogLevel.INFO)) {
-            console.info(this.formatMessage(message, 'INFO'), ...args);
-        }
-    }
-    /**
-     * Log warning message
-     */
-    warn(message, ...args) {
-        if (this.shouldLog(LogLevel.WARN)) {
-            console.warn(this.formatMessage(message, 'WARN'), ...args);
-        }
-    }
-    /**
-     * Log error message
-     */
-    error(message, error, ...args) {
-        if (this.shouldLog(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(LogLevel.INFO)) {
-            console.group(this.formatMessage(label, 'GROUP'));
-            callback();
-            console.groupEnd();
-        }
-    }
-    /**
-     * Log a collapsed group of messages
-     */
-    groupCollapsed(label, callback) {
-        if (this.shouldLog(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(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');
- *   }
- * }
- * ```
- */
-let LoggerService = class LoggerService extends Logger {
-    constructor() {
-        super();
-    }
-};
-LoggerService = __decorate([
-    Injectable({
-        providedIn: 'root'
-    }),
-    __metadata("design:paramtypes", [])
-], LoggerService);
-
-/**
- * PermissionService - Manages user permissions and roles
- */
-let PermissionService = class PermissionService {
-    tokenService = inject(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;
-    }
-};
-PermissionService = __decorate([
-    Injectable({
-        providedIn: 'root'
-    })
-], PermissionService);
-
 function mitt(n){return {all:n=n||new Map,on:function(t,e){var i=n.get(t);i?i.push(e):n.set(t,[e]);},off:function(t,e){var i=n.get(t);i&&(e?i.splice(i.indexOf(e)>>>0,1):n.set(t,[]));},emit:function(t,e){var i=n.get(t);i&&i.slice().map(function(n){n(e);}),(i=n.get("*"))&&i.slice().map(function(n){n(t,e);});}}}
 
 /**
@@ -1490,404 +673,5 @@ AuthService = __decorate([
         EventBusService])
 ], AuthService);
 
-/**
- * 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 = inject(TokenService);
-        const router = inject(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.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 = inject(TokenService);
-        const router = inject(Router);
-        const redirectUrl = config.redirectUrl || '/unauthorized';
-        // First check authentication
-        if (!tokenService.isAuthenticated()) {
-            router.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.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 = inject(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 = inject(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
-    retry({
-        count: config.retryAttempts,
-        delay: (error, retryCount) => {
-            // Only retry for specific status codes
-            if (!config.retryStatusCodes?.includes(error.status)) {
-                return 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 timer(delay);
-        }
-    }), 
-    // Error handling
-    catchError((error) => {
-        if (config.enableLogging) {
-            logger.error('HTTP request failed', error, {
-                url: req.url,
-                status: error.status,
-                message: error.message
-            });
-        }
-        return 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 = inject(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 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(tap(event => {
-        if (event instanceof HttpResponse) {
-            evictOldestIfFull();
-            cache.set(cacheKey, {
-                response: event.clone(),
-                timestamp: Date.now()
-            });
-            logger.debug(`Cached response for ${cacheKey}`);
-        }
-    }));
-};
-
-export { AUTH0_CONFIG, AuthService, EventBusService, HttpError, LogLevel, LoggerService, NgEventEmitter, PermissionService, STORAGE_CONFIG, STORAGE_KEYS, StorageService, TokenService, authGuard, authInterceptor, cachingInterceptor, clearCache, clearCacheEntry, configureAuth0, configureAuthInterceptor, configureCaching, configureErrorHandling, createAuthGuard, createPermissionGuard, createRoleGuard, errorHandlingInterceptor, getStorageItem, isClientError, isNetworkError, isServerError, parseHttpError, removeStorageItem, setStorageItem };
+export { AUTH0_CONFIG, AuthService, EventBusService, STORAGE_CONFIG, STORAGE_KEYS, configureAuth0, getStorageItem, removeStorageItem, setStorageItem };
 //# sourceMappingURL=index.mjs.map