content-security-toolkit 1.0.0 → 1.0.1

package/dist/utils/logging/LogLevel.js

@@ -1,46 +0,0 @@
-/**
- * Enum defining log severity levels
- */
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
-    LogLevel[LogLevel["WARN"] = 1] = "WARN";
-    LogLevel[LogLevel["INFO"] = 2] = "INFO";
-    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
-    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
-    LogLevel[LogLevel["VERBOSE"] = 5] = "VERBOSE";
-})(LogLevel || (LogLevel = {}));
-/**
- * Map of log level names to their enum values
- */
-export const LOG_LEVEL_MAP = {
-    error: LogLevel.ERROR,
-    warn: LogLevel.WARN,
-    info: LogLevel.INFO,
-    debug: LogLevel.DEBUG,
-    trace: LogLevel.TRACE,
-    verbose: LogLevel.VERBOSE,
-};
-/**
- * Get the name of a log level
- * @param level The log level
- * @returns The name of the log level
- */
-export function getLogLevelName(level) {
-    switch (level) {
-        case LogLevel.ERROR:
-            return "ERROR";
-        case LogLevel.WARN:
-            return "WARN";
-        case LogLevel.INFO:
-            return "INFO";
-        case LogLevel.DEBUG:
-            return "DEBUG";
-        case LogLevel.TRACE:
-            return "TRACE";
-        case LogLevel.VERBOSE:
-            return "VERBOSE";
-        default:
-            return "UNKNOWN";
-    }
-}

package/dist/utils/logging/LoggingConfig.d.ts

@@ -1,68 +0,0 @@
-import { LogLevel } from "./LogLevel";
-/**
- * Global logging configuration
- */
-export interface LoggingConfig {
-    /**
-     * Default log level for all components
-     * @default LogLevel.INFO
-     */
-    defaultLevel: LogLevel;
-    /**
-     * Component-specific log levels
-     */
-    componentLevels: Record<string, LogLevel>;
-    /**
-     * Whether to use colors in console output
-     * @default true
-     */
-    useColors: boolean;
-    /**
-     * Whether to include timestamps in logs
-     * @default true
-     */
-    includeTimestamps: boolean;
-    /**
-     * Whether to include component names in logs
-     * @default true
-     */
-    includeComponentName: boolean;
-    /**
-     * Components to enable logging for (null means all)
-     */
-    enabledComponents: string[] | null;
-    /**
-     * Level to focus on (null means all levels)
-     */
-    focusedLevel: LogLevel | null;
-}
-/**
- * Default logging configuration
- */
-export declare const DEFAULT_LOGGING_CONFIG: LoggingConfig;
-/**
- * Get the current logging configuration
- * @returns The current logging configuration
- */
-export declare function getLoggingConfig(): LoggingConfig;
-/**
- * Update the logging configuration
- * @param config New configuration (partial)
- */
-export declare function updateLoggingConfig(config: Partial<LoggingConfig>): void;
-/**
- * Reset the logging configuration to defaults
- */
-export declare function resetLoggingConfig(): void;
-/**
- * Get the log level for a specific component
- * @param componentName Component name
- * @returns The log level for the component
- */
-export declare function getComponentLogLevel(componentName: string): LogLevel;
-/**
- * Set the log level for a specific component
- * @param componentName Component name
- * @param level Log level
- */
-export declare function setComponentLogLevel(componentName: string, level: LogLevel): void;

package/dist/utils/logging/LoggingConfig.js

@@ -1,64 +0,0 @@
-import { LogLevel } from "./LogLevel";
-/**
- * Default logging configuration
- */
-export const DEFAULT_LOGGING_CONFIG = {
-    defaultLevel: LogLevel.INFO,
-    componentLevels: {},
-    useColors: true,
-    includeTimestamps: true,
-    includeComponentName: true,
-    enabledComponents: null,
-    focusedLevel: null,
-};
-/**
- * Current global logging configuration
- */
-let currentConfig = { ...DEFAULT_LOGGING_CONFIG };
-/**
- * Get the current logging configuration
- * @returns The current logging configuration
- */
-export function getLoggingConfig() {
-    return { ...currentConfig };
-}
-/**
- * Update the logging configuration
- * @param config New configuration (partial)
- */
-export function updateLoggingConfig(config) {
-    currentConfig = {
-        ...currentConfig,
-        ...config,
-        // Merge component levels
-        componentLevels: {
-            ...currentConfig.componentLevels,
-            ...(config.componentLevels || {}),
-        },
-    };
-    console.log("Updated logging configuration:", currentConfig);
-}
-/**
- * Reset the logging configuration to defaults
- */
-export function resetLoggingConfig() {
-    currentConfig = { ...DEFAULT_LOGGING_CONFIG };
-    console.log("Reset logging configuration to defaults");
-}
-/**
- * Get the log level for a specific component
- * @param componentName Component name
- * @returns The log level for the component
- */
-export function getComponentLogLevel(componentName) {
-    return currentConfig.componentLevels[componentName] || currentConfig.defaultLevel;
-}
-/**
- * Set the log level for a specific component
- * @param componentName Component name
- * @param level Log level
- */
-export function setComponentLogLevel(componentName, level) {
-    currentConfig.componentLevels[componentName] = level;
-    console.log(`Set log level for ${componentName} to ${LogLevel[level]}`);
-}

package/dist/utils/logging/LoggingFactory.d.ts

@@ -1,22 +0,0 @@
-import { LoggingService } from "./LoggingService";
-/**
- * Factory for creating LoggingService instances
- */
-export declare class LoggingFactory {
-    private static instances;
-    /**
-     * Get a LoggingService instance for a component
-     * @param componentName Component name
-     * @returns LoggingService instance
-     */
-    static getLogger(componentName: string): LoggingService;
-    /**
-     * Update all existing logger instances with current configuration
-     */
-    static updateAllLoggers(): void;
-    /**
-     * Get all registered logger instances
-     * @returns Map of component names to logger instances
-     */
-    static getAllLoggers(): Map<string, LoggingService>;
-}

package/dist/utils/logging/LoggingFactory.js

@@ -1,61 +0,0 @@
-import { LoggingService } from "./LoggingService";
-import { getComponentLogLevel, getLoggingConfig } from "./LoggingConfig";
-/**
- * Factory for creating LoggingService instances
- */
-export class LoggingFactory {
-    /**
-     * Get a LoggingService instance for a component
-     * @param componentName Component name
-     * @returns LoggingService instance
-     */
-    static getLogger(componentName) {
-        // Check if we already have an instance for this component
-        if (this.instances.has(componentName)) {
-            return this.instances.get(componentName);
-        }
-        // Get the global config
-        const config = getLoggingConfig();
-        // Create a new instance
-        const logger = new LoggingService({
-            componentName,
-            level: getComponentLogLevel(componentName),
-            useColors: config.useColors,
-            includeTimestamps: config.includeTimestamps,
-            includeComponentName: config.includeComponentName,
-        });
-        // Apply global settings
-        if (config.enabledComponents !== null) {
-            logger.setEnabledComponents(config.enabledComponents);
-        }
-        if (config.focusedLevel !== null) {
-            logger.focusLevel(config.focusedLevel);
-        }
-        // Store the instance
-        this.instances.set(componentName, logger);
-        return logger;
-    }
-    /**
-     * Update all existing logger instances with current configuration
-     */
-    static updateAllLoggers() {
-        const config = getLoggingConfig();
-        for (const [componentName, logger] of this.instances.entries()) {
-            logger.setLevel(getComponentLogLevel(componentName));
-            if (config.enabledComponents !== null) {
-                logger.setEnabledComponents(config.enabledComponents);
-            }
-            if (config.focusedLevel !== null) {
-                logger.focusLevel(config.focusedLevel);
-            }
-        }
-    }
-    /**
-     * Get all registered logger instances
-     * @returns Map of component names to logger instances
-     */
-    static getAllLoggers() {
-        return new Map(this.instances);
-    }
-}
-LoggingFactory.instances = new Map();

package/dist/utils/logging/LoggingService.d.ts

@@ -1,235 +0,0 @@
-import { LogLevel } from "./LogLevel";
-/**
- * Options for the LoggingService
- */
-export interface LoggingOptions {
-    /**
-     * Component name for log prefixing
-     */
-    componentName: string;
-    /**
-     * Initial log level
-     * @default LogLevel.INFO
-     */
-    level?: LogLevel;
-    /**
-     * Whether logging is enabled
-     * @default true
-     */
-    enabled?: boolean;
-    /**
-     * Whether to use colors in console output
-     * @default true
-     */
-    useColors?: boolean;
-    /**
-     * Whether to include timestamps in logs
-     * @default true
-     */
-    includeTimestamps?: boolean;
-    /**
-     * Whether to include component name in logs
-     * @default true
-     */
-    includeComponentName?: boolean;
-}
-/**
- * Performance timing result
- */
-export interface TimingResult<T> {
-    result: T;
-    duration: number;
-}
-/**
- * Advanced logging service with context tracking, filtering, and performance measurement
- */
-export declare class LoggingService {
-    private componentName;
-    private currentLevel;
-    private enabled;
-    private useColors;
-    private includeTimestamps;
-    private includeComponentName;
-    private contextStack;
-    private contextDepth;
-    private enabledComponents;
-    private focusedLevel;
-    private groupDepth;
-    /**
-     * Create a new LoggingService
-     * @param options Configuration options
-     */
-    constructor(options: LoggingOptions);
-    /**
-     * Set the current log level threshold
-     * @param level New log level
-     */
-    setLevel(level: LogLevel): void;
-    /**
-     * Get the current log level
-     * @returns The current log level
-     */
-    getLevel(): LogLevel;
-    /**
-     * Get the current log level name
-     * @returns The current log level name
-     */
-    getLevelName(): string;
-    /**
-     * Enable or disable logging
-     * @param enabled Whether logging should be enabled
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * Check if logging is enabled
-     * @returns Whether logging is enabled
-     */
-    isEnabled(): boolean;
-    /**
-     * Set components to show logs for
-     * @param components Array of component names to enable, or null to enable all
-     */
-    setEnabledComponents(components: string[] | null): void;
-    /**
-     * Focus on a specific log level
-     * @param level Level to focus on, or null to show all levels
-     */
-    focusLevel(level: LogLevel | null): void;
-    /**
-     * Increase context depth (call when entering a loop or nested function)
-     * @param contextName Optional name for the context
-     * @returns A function that exits this context when called
-     */
-    enterContext(contextName?: string): () => void;
-    /**
-     * Decrease context depth (call when exiting a loop or nested function)
-     */
-    exitContext(): void;
-    /**
-     * Execute a function within a named context
-     * @param contextName Name for the context
-     * @param fn Function to execute
-     * @returns The result of the function
-     */
-    withContext<T>(contextName: string, fn: () => T): T;
-    /**
-     * Execute an async function within a named context
-     * @param contextName Name for the context
-     * @param fn Async function to execute
-     * @returns Promise resolving to the result of the function
-     */
-    withContextAsync<T>(contextName: string, fn: () => Promise<T>): Promise<T>;
-    /**
-     * Start a console group
-     * @param label Label for the group
-     * @param collapsed Whether the group should be collapsed
-     */
-    startGroup(label: string, collapsed?: boolean): void;
-    /**
-     * End the current console group
-     */
-    endGroup(): void;
-    /**
-     * Execute a function within a console group
-     * @param label Label for the group
-     * @param fn Function to execute
-     * @param collapsed Whether the group should be collapsed
-     * @returns The result of the function
-     */
-    group<T>(label: string, fn: () => T, collapsed?: boolean): T;
-    /**
-     * Execute an async function within a console group
-     * @param label Label for the group
-     * @param fn Async function to execute
-     * @param collapsed Whether the group should be collapsed
-     * @returns Promise resolving to the result of the function
-     */
-    groupAsync<T>(label: string, fn: () => Promise<T>, collapsed?: boolean): Promise<T>;
-    /**
-     * Measure the execution time of a function
-     * @param label Label for the timing
-     * @param fn Function to measure
-     * @returns Object containing the result and duration
-     */
-    time<T>(label: string, fn: () => T): TimingResult<T>;
-    /**
-     * Measure the execution time of an async function
-     * @param label Label for the timing
-     * @param fn Async function to measure
-     * @returns Promise resolving to an object containing the result and duration
-     */
-    timeAsync<T>(label: string, fn: () => Promise<T>): Promise<TimingResult<T>>;
-    /**
-     * Log with automatic level adjustment based on context depth
-     * @param message Message to log
-     * @param args Additional arguments to log
-     */
-    logWithContext(message: string, ...args: unknown[]): void;
-    /**
-     * Main logging method
-     * @param level Log level
-     * @param message Message to log
-     * @param args Additional arguments to log
-     */
-    log(level: LogLevel, message: string, ...args: unknown[]): void;
-    /**
-     * Log an error message
-     * @param message Error message
-     * @param args Additional arguments to log
-     */
-    error(message: string, ...args: unknown[]): void;
-    /**
-     * Log a warning message
-     * @param message Warning message
-     * @param args Additional arguments to log
-     */
-    warn(message: string, ...args: unknown[]): void;
-    /**
-     * Log an info message
-     * @param message Info message
-     * @param args Additional arguments to log
-     */
-    info(message: string, ...args: unknown[]): void;
-    /**
-     * Log a debug message
-     * @param message Debug message
-     * @param args Additional arguments to log
-     */
-    debug(message: string, ...args: unknown[]): void;
-    /**
-     * Log a trace message
-     * @param message Trace message
-     * @param args Additional arguments to log
-     */
-    trace(message: string, ...args: unknown[]): void;
-    /**
-     * Log a verbose message
-     * @param message Verbose message
-     * @param args Additional arguments to log
-     */
-    verbose(message: string, ...args: unknown[]): void;
-    /**
-     * Check if a message should be logged
-     * @param level Log level of the message
-     * @returns Whether the message should be logged
-     */
-    private shouldLog;
-    /**
-     * Format a log message
-     * @param level Log level
-     * @param message Message to format
-     * @returns Formatted message
-     */
-    private formatMessage;
-    /**
-     * Get the current timestamp as a string
-     * @returns Formatted timestamp
-     */
-    private getTimestamp;
-    /**
-     * Get prefix for log level
-     * @param level Log level
-     * @returns Formatted prefix
-     */
-    private getLevelPrefix;
-}